Upload folder using huggingface_hub

.meta.json

@@ -0,0 +1,6 @@
+{
+  "safetensors": "0.8.0",
+  "torch": "2.11.0+cu128",
+  "transformers": "5.14.0.dev0",
+  "vllm": "0.24.0+cu129"
+}

README.md

@@ -0,0 +1,441 @@
+---
+library_name: transformers
+base_model:
+- deepseek-ai/DeepSeek-V4-Pro
+---
+
+This tiny model is intended for debugging. It is randomly initialized using the configuration adapted from [deepseek-ai/DeepSeek-V4-Pro](https://huggingface.co/deepseek-ai/DeepSeek-V4-Pro).
+
+Note:
+  - This model follows the quantization scheme of "FP4 + FP8 Mixed": MoE expert parameters use FP4 precision; most other parameters use FP8.
+  - Chat template from [this PR](https://huggingface.co/deepseek-ai/DeepSeek-V4-Pro/discussions/146/files).
+
+| File path | Size |
+|------|------|
+| model.safetensors | 144.5MB |
+
+
+### Example usage:
+
+- vLLM
+
+```bash
+# Not fully tested, please raise an issue if you find any problems.
+model_id=tiny-random/deepseek-v4
+vllm serve $model_id \
+  --trust-remote-code \
+  --kv-cache-dtype fp8 \
+  --block-size 256 \
+  --tensor-parallel-size 2 \
+  --no-enable-flashinfer-autotune \
+  --tokenizer-mode deepseek_v4 \
+  --tool-call-parser deepseek_v4 \
+  --enable-auto-tool-choice \
+  --reasoning-parser deepseek_v4 \
+  --speculative-config '{"method":"mtp","num_speculative_tokens":2}'
+```
+
+### Codes to create this repo:
+
+<details><summary>Click to expand</summary>
+
+```python
+import json
+import hashlib
+from pathlib import Path
+from typing import Any, Literal, TypedDict
+
+import torch
+from huggingface_hub import file_exists, hf_hub_download
+from safetensors.torch import save_file
+from transformers import AutoTokenizer, GenerationConfig
+
+source_model_id = "deepseek-ai/DeepSeek-V4-Pro"
+save_folder = "/tmp/tiny-random/deepseek-v4"
+config = {
+    "architectures": [
+        "DeepseekV4ForCausalLM"
+    ],
+    "attention_bias": True,
+    "attention_dropout": 0.0,
+    "bos_token_id": 0,
+    "eos_token_id": 1,
+    "expert_dtype": "fp4",
+    "hc_eps": 1e-06,
+    "hc_mult": 4,
+    "hc_sinkhorn_iters": 20,
+    "head_dim": 128,
+    "hidden_act": "silu",
+    "hidden_size": 128,
+    "index_head_dim": 128,
+    "index_n_heads": 4,
+    "index_topk": 1024,
+    "initializer_range": 0.02,
+    "max_position_embeddings": 1048576,
+    "model_type": "deepseek_v4",
+    "moe_intermediate_size": 128,
+    "n_routed_experts": 256,
+    "n_shared_experts": 1,
+    "norm_topk_prob": True,
+    "num_attention_heads": 4,
+    "num_experts_per_tok": 6,
+    "num_hidden_layers": 7,
+    "num_hash_layers": 3,
+    "num_key_value_heads": 1,
+    "num_nextn_predict_layers": 1,
+    "o_groups": 2,
+    "o_lora_rank": 128,
+    "q_lora_rank": 128,
+    "qk_rope_head_dim": 64,
+    "quantization_config": {
+        "activation_scheme": "dynamic",
+        "fmt": "e4m3",
+        "quant_method": "fp8",
+        "scale_fmt": "ue8m0",
+        "weight_block_size": [
+            128,
+            128
+        ]
+    },
+    "rms_norm_eps": 1e-06,
+    "rope_scaling": {
+        "beta_fast": 32,
+        "beta_slow": 1,
+        "factor": 16,
+        "original_max_position_embeddings": 65536,
+        "type": "yarn"
+    },
+    "rope_theta": 10000,
+    "routed_scaling_factor": 2.5,
+    "scoring_func": "sqrtsoftplus",
+    "sliding_window": 128,
+    "swiglu_limit": 10.0,
+    "tie_word_embeddings": False,
+    "topk_method": "noaux_tc",
+    "torch_dtype": "bfloat16",
+    "transformers_version": "4.57.1",
+    "use_cache": True,
+    "vocab_size": 129280,
+    "compress_rope_theta": 160000,
+    "compress_ratios": [128, 128, 4, 128, 4, 128, 4, 0]
+}
+
+def main():
+    torch.manual_seed(42)
+    Path(save_folder).mkdir(parents=True, exist_ok=True)
+    state_dict = generate(config)
+    save_file(state_dict, Path(save_folder) / "model.safetensors")
+    with open(Path(save_folder) / "model.safetensors", "rb") as f:
+        state_dict = f.read()
+        print("Hash: ", hashlib.sha256(state_dict).hexdigest())
+
+    with open(Path(save_folder) / "config.json", "w", encoding="utf-8") as f:
+        json.dump(config, f, indent=2, ensure_ascii=False)
+
+    tokenizer = AutoTokenizer.from_pretrained(
+        source_model_id, trust_remote_code=True,
+    )
+    if file_exists(filename="chat_template.jinja", repo_id=source_model_id, repo_type='model', revision="refs/pr/146"):
+        with open(hf_hub_download(
+            source_model_id,
+            filename="chat_template.jinja",
+            repo_type='model',
+            revision="refs/pr/146",
+        ), 'r', encoding='utf-8') as f:
+            tokenizer.chat_template = f.read()
+    tokenizer.save_pretrained(save_folder)
+
+    generation_config = GenerationConfig.from_pretrained(
+        source_model_id, trust_remote_code=True,
+    )
+    generation_config.save_pretrained(save_folder)
+
+BF16 = "torch.bfloat16"
+F32 = "torch.float32"
+FP8 = "torch.float8_e4m3fn"
+SCALE = "torch.float8_e8m0fnu"
+I8 = "torch.int8"
+I64 = "torch.int64"
+
+class TensorSpec(TypedDict):
+    shape: list[int]
+    dtype: str
+
+Config = dict[str, Any]
+State = dict[str, TensorSpec]
+TensorDict = dict[str, torch.Tensor]
+WeightKind = Literal["bf16", "fp8", "fp4"]
+
+def initialize(state: State, config: Config, init_bound: float) -> TensorDict:
+    tensors: TensorDict = {}
+    scale_dtype = torch.float8_e8m0fnu
+    fp4_boundaries = torch.tensor([0.25, 0.75, 1.25, 1.75, 2.5, 3.5, 5.0])
+
+    def scale_for(
+        amax: torch.Tensor, qmax: float, dtype: torch.dtype
+    ) -> torch.Tensor:
+        scale = amax.float().clamp_min(torch.finfo(torch.float32).tiny) / qmax
+        if dtype == scale_dtype:
+            scale = torch.pow(2.0, torch.round(torch.log2(scale)))
+        return scale.to(dtype)
+
+    def fp8_tensor(
+        shape: list[int], scale_shape: list[int], dtype: torch.dtype
+    ) -> tuple[torch.Tensor, torch.Tensor]:
+        block_out, block_in = config["quantization_config"]["weight_block_size"]
+        assert shape == [scale_shape[0] * block_out, scale_shape[1] * block_in]
+        value = torch.empty(shape, dtype=torch.bfloat16).uniform_(
+            -init_bound, init_bound
+        )
+        blocks = value.view(
+            scale_shape[0], block_out, scale_shape[1], block_in
+        ).transpose(1, 2)
+        scales = scale_for(blocks.abs().amax(dim=(-1, -2)), 448, dtype)
+        weight = (
+            (blocks.float() / scales.float()[..., None, None])
+            .clamp(-448, 448)
+            .to(torch.float8_e4m3fn)
+            .transpose(1, 2)
+            .reshape(shape)
+            .contiguous()
+        )
+        return weight, scales
+
+    def fp4_tensors(
+        count: int,
+        shape: list[int],
+        scale_shape: list[int],
+        dtype: torch.dtype,
+    ) -> tuple[torch.Tensor, torch.Tensor]:
+        out_dim, packed_in_dim = shape
+        block_out, block_in = config["quantization_config"]["weight_block_size"]
+        assert out_dim % block_out == 0
+        assert packed_in_dim * 2 % block_in == 0
+        assert packed_in_dim == scale_shape[1] * 16
+        value = torch.empty(
+            count, out_dim, packed_in_dim * 2, dtype=torch.bfloat16
+        ).uniform_(-init_bound, init_bound)
+        blocks = value.view(count, out_dim, scale_shape[1], 32)
+        scales = scale_for(blocks.abs().amax(dim=-1), 6, dtype)
+        normalized = (blocks.float() / scales.float()[..., None]).clamp(-6, 6)
+        code = torch.bucketize(normalized.abs(), fp4_boundaries)
+        code += normalized.signbit() * 8
+        code = code.view(count, out_dim, packed_in_dim * 2)
+        packed = (code[..., ::2] | (code[..., 1::2] << 4)).to(torch.uint8)
+        weight = packed.view(torch.int8).contiguous()
+        return weight, scales
+
+    dtype_map: dict[str, torch.dtype] = {
+        BF16: torch.bfloat16,
+        F32: torch.float32,
+        FP8: torch.float8_e4m3fn,
+        SCALE: scale_dtype,
+        I8: torch.int8,
+        I64: torch.int64,
+    }
+    fp4_groups: dict[
+        tuple[tuple[int, ...], tuple[int, ...], torch.dtype], list[str]
+    ] = {}
+    for name, spec in state.items():
+        if spec["dtype"] != I8:
+            continue
+        scale_spec = state[name.replace(".weight", ".scale")]
+        key = (
+            tuple(spec["shape"]),
+            tuple(scale_spec["shape"]),
+            dtype_map[scale_spec["dtype"]],
+        )
+        fp4_groups.setdefault(key, []).append(name)
+
+    fp4_cache: dict[str, tuple[torch.Tensor, torch.Tensor]] = {}
+    max_batch_elements = 4 * 1024 * 1024
+    for (shape_tuple, scale_shape_tuple, dtype), names in fp4_groups.items():
+        shape = list(shape_tuple)
+        scale_shape = list(scale_shape_tuple)
+        logical_elements = shape[0] * shape[1] * 2
+        batch_size = max(1, max_batch_elements // logical_elements)
+        for start in range(0, len(names), batch_size):
+            batch_names = names[start: start + batch_size]
+            weights, scales = fp4_tensors(
+                len(batch_names), shape, scale_shape, dtype
+            )
+            for index, name in enumerate(batch_names):
+                fp4_cache[name] = (
+                    weights[index].clone(),
+                    scales[index].clone(),
+                )
+
+    for name, spec in state.items():
+        if name in tensors:
+            continue
+        shape, dtype = spec["shape"], dtype_map[spec["dtype"]]
+        scale_name = name.replace(".weight", ".scale")
+        if spec["dtype"] == FP8:
+            scale_spec = state[scale_name]
+            scale_type = dtype_map[scale_spec["dtype"]]
+            tensors[name], tensors[scale_name] = fp8_tensor(
+                shape, scale_spec["shape"], scale_type
+            )
+        elif spec["dtype"] == I8:
+            tensors[name], tensors[scale_name] = fp4_cache.pop(name)
+        elif spec["dtype"] == I64:
+            tensors[name] = torch.randint(
+                config["n_routed_experts"], shape, dtype=dtype
+            )
+        elif not name.endswith(".scale"):
+            tensors[name] = torch.empty(shape, dtype=dtype).uniform_(
+                -init_bound, init_bound
+            )
+        print(f"{name}: {shape} {dtype}", flush=True)
+    file_size_by_name = {name: tensor.numel() * tensor.element_size() for name, tensor in tensors.items()}
+    total_file_size = sum(file_size_by_name.values())
+    k = 20
+    topk = sorted(file_size_by_name.items(), key=lambda x: x[1], reverse=True)[:k]
+    print(f"File size: {total_file_size / 1024 / 1024:.2f} MB")
+    print(f"Top {k} largest tensors:")
+    for name, size in topk:
+        print(f"  {name}: {size / 1024 / 1024:.2f} MB")
+    return tensors
+
+def generate(
+    config: Config, init_bound: float = 0.2
+) -> TensorDict:
+    assert init_bound > 0
+    state: State = {}
+    dim = config["hidden_size"]
+    inter = config["moe_intermediate_size"]
+    heads = config["num_attention_heads"]
+    head_dim = config["head_dim"]
+    q_rank = config["q_lora_rank"]
+    o_rank = config["o_lora_rank"]
+    o_groups = config["o_groups"]
+    experts = config["n_routed_experts"]
+    vocab = config["vocab_size"]
+    hc = config["hc_mult"]
+    quant = config["quantization_config"]
+    block_out, block_in = quant["weight_block_size"]
+    weight_kind: WeightKind = (
+        "fp8" if quant["quant_method"] == "fp8" else "bf16"
+    )
+    scale_dtype = SCALE if quant.get("scale_fmt") == "ue8m0" else F32
+
+    def add(name: str, shape: list[int], dtype: str) -> None:
+        state[name] = {"shape": shape, "dtype": dtype}
+
+    def linear(
+        name: str, out_dim: int, in_dim: int, kind: WeightKind = weight_kind
+    ) -> None:
+        if kind == "fp4":
+            assert out_dim % block_out == 0 and in_dim % block_in == 0, (
+                f"{name} shape [{out_dim}, {in_dim}] is not divisible by "
+                f"block size [{block_out}, {block_in}]"
+            )
+            add(f"{name}.weight", [out_dim, in_dim // 2], I8)
+            add(f"{name}.scale", [out_dim, in_dim // 32], scale_dtype)
+        elif kind == "fp8":
+            assert out_dim % block_out == 0 and in_dim % block_in == 0, (
+                f"{name} shape [{out_dim}, {in_dim}] is not divisible by "
+                f"block size [{block_out}, {block_in}]"
+            )
+            add(f"{name}.weight", [out_dim, in_dim], FP8)
+            add(
+                f"{name}.scale",
+                [out_dim // block_out, in_dim // block_in],
+                scale_dtype,
+            )
+        else:
+            add(f"{name}.weight", [out_dim, in_dim], BF16)
+
+    def compressor(name: str, ratio: int, size: int) -> None:
+        out_dim = size * (2 if ratio == 4 else 1)
+        add(f"{name}.ape", [ratio, out_dim], F32)
+        add(f"{name}.wkv.weight", [out_dim, dim], BF16)
+        add(f"{name}.wgate.weight", [out_dim, dim], BF16)
+        add(f"{name}.norm.weight", [size], BF16)
+
+    def attention(name: str, ratio: int) -> None:
+        add(f"{name}.attn_sink", [heads], F32)
+        linear(f"{name}.wq_a", q_rank, dim)
+        add(f"{name}.q_norm.weight", [q_rank], BF16)
+        linear(f"{name}.wq_b", heads * head_dim, q_rank)
+        linear(f"{name}.wkv", head_dim, dim)
+        add(f"{name}.kv_norm.weight", [head_dim], BF16)
+        linear(f"{name}.wo_a", o_groups * o_rank, heads * head_dim // o_groups)
+        linear(f"{name}.wo_b", dim, o_groups * o_rank)
+
+        if ratio:
+            compressor(f"{name}.compressor", ratio, head_dim)
+        if ratio == 4:
+            index_heads = config["index_n_heads"]
+            index_dim = config["index_head_dim"]
+            linear(f"{name}.indexer.wq_b", index_heads * index_dim, q_rank)
+            add(f"{name}.indexer.weights_proj.weight", [index_heads, dim], BF16)
+            compressor(f"{name}.indexer.compressor", ratio, index_dim)
+
+    def expert(name: str, kind: WeightKind) -> None:
+        linear(f"{name}.w1", inter, dim, kind)
+        linear(f"{name}.w2", dim, inter, kind)
+        linear(f"{name}.w3", inter, dim, kind)
+
+    def moe(name: str, layer_id: int) -> None:
+        add(f"{name}.gate.weight", [experts, dim], BF16)
+        if layer_id < config["num_hash_layers"]:
+            add(
+                f"{name}.gate.tid2eid",
+                [vocab, config["num_experts_per_tok"]],
+                I64,
+            )
+        else:
+            add(f"{name}.gate.bias", [experts], F32)
+
+        routed_kind = "fp4" if config.get("expert_dtype") == "fp4" else weight_kind
+        for expert_id in range(experts):
+            expert(f"{name}.experts.{expert_id}", routed_kind)
+        expert(f"{name}.shared_experts", weight_kind)
+
+    def block(name: str, layer_id: int) -> None:
+        attention(f"{name}.attn", config["compress_ratios"][layer_id])
+        moe(f"{name}.ffn", layer_id)
+        add(f"{name}.attn_norm.weight", [dim], BF16)
+        add(f"{name}.ffn_norm.weight", [dim], BF16)
+        for part in ("attn", "ffn"):
+            add(f"{name}.hc_{part}_fn", [(2 + hc) * hc, hc * dim], F32)
+            add(f"{name}.hc_{part}_base", [(2 + hc) * hc], F32)
+            add(f"{name}.hc_{part}_scale", [3], F32)
+
+    def hc_head(name: str = "") -> None:
+        prefix = f"{name}." if name else ""
+        add(f"{prefix}hc_head_fn", [hc, hc * dim], F32)
+        add(f"{prefix}hc_head_base", [hc], F32)
+        add(f"{prefix}hc_head_scale", [1], F32)
+
+    add("embed.weight", [vocab, dim], BF16)
+    for layer_id in range(config["num_hidden_layers"]):
+        block(f"layers.{layer_id}", layer_id)
+    add("norm.weight", [dim], BF16)
+    add("head.weight", [vocab, dim], BF16)
+    hc_head()
+
+    first_mtp_layer = config["num_hidden_layers"]
+    for mtp_id in range(config["num_nextn_predict_layers"]):
+        name = f"mtp.{mtp_id}"
+        block(name, first_mtp_layer + mtp_id)
+        linear(f"{name}.e_proj", dim, dim)
+        linear(f"{name}.h_proj", dim, dim)
+        for norm in ("enorm", "hnorm", "norm"):
+            add(f"{name}.{norm}.weight", [dim], BF16)
+        hc_head(name)
+
+    return initialize(state, config, init_bound)
+
+main()
+```
+
+</details>
+
+### Test environment:
+
+- safetensors: 0.8.0
+- torch: 2.11.0+cu128
+- transformers: 5.14.0.dev0
+- vllm: 0.24.0+cu129

chat_template.jinja

@@ -0,0 +1,208 @@
+{%- macro render_tools_block(eff_tools) -%}
+{%- set tl_ns = namespace(lines=[]) -%}
+{%- for t in eff_tools -%}
+    {%- if t.function is defined -%}
+        {%- set tl_ns.lines = tl_ns.lines + [t.function | tojson(ensure_ascii=false)] -%}
+    {%- else -%}
+        {%- set tl_ns.lines = tl_ns.lines + [t | tojson(ensure_ascii=false)] -%}
+    {%- endif -%}
+{%- endfor -%}
+{{- "\n\n## Tools\n\nYou have access to a set of tools to help answer the user's question. You can invoke tools by writing a \"<｜DSML｜tool_calls>\" block like the following:\n\n<｜DSML｜tool_calls>\n<｜DSML｜invoke name=\"$TOOL_NAME\">\n<｜DSML｜parameter name=\"$PARAMETER_NAME\" string=\"true|false\">$PARAMETER_VALUE</｜DSML｜parameter>\n...\n</｜DSML｜invoke>\n<｜DSML｜invoke name=\"$TOOL_NAME2\">\n...\n</｜DSML｜invoke>\n</｜DSML｜tool_calls>\n\nString parameters should be specified as is and set `string=\"true\"`. For all other types (numbers, booleans, arrays, objects), pass the value in JSON format and set `string=\"false\"`.\n\nIf thinking_mode is enabled (triggered by <think>), you MUST output your complete reasoning inside <think>...</think> BEFORE any tool calls or final response.\n\nOtherwise, output directly after </think> with tool calls or final response.\n\n### Available Tool Schemas\n\n" -}}
+{{- tl_ns.lines | join("\n") -}}
+{{- "\n\nYou MUST strictly follow the above defined tool name and parameter schemas to invoke tool calls.\n" -}}
+{%- endmacro -%}
+
+{%- macro render_response_format(rf) -%}
+{{- "\n\n## Response Format:\n\nYou MUST strictly adhere to the following schema to reply:\n" -}}
+{{- rf | tojson(ensure_ascii=false) -}}
+{%- endmacro -%}
+
+{%- if thinking_mode is not defined -%}{%- set thinking_mode = "thinking" -%}{%- endif -%}
+{%- if drop_thinking is not defined -%}{%- set drop_thinking = true -%}{%- endif -%}
+{%- if reasoning_effort is not defined -%}{%- set reasoning_effort = none -%}{%- endif -%}
+{%- if tools is not defined -%}{%- set tools = none -%}{%- endif -%}
+{%- if add_generation_prompt is not defined -%}{%- set add_generation_prompt = false -%}{%- endif -%}
+
+{%- set tools_ns = namespace(has_any=false) -%}
+{%- if tools -%}{%- set tools_ns.has_any = true -%}{%- endif -%}
+{%- for m in messages -%}
+    {%- if m.tools -%}{%- set tools_ns.has_any = true -%}{%- endif -%}
+{%- endfor -%}
+{%- set effective_drop = drop_thinking and (not tools_ns.has_any) -%}
+
+{%- set mns = namespace(list=[]) -%}
+{%- for msg in messages -%}
+    {%- if msg.role == "tool" -%}
+        {%- set tblock = {"type": "tool_result", "tool_use_id": msg.get("tool_call_id", ""), "content": msg.content} -%}
+        {%- if mns.list|length > 0 and mns.list[-1].role == "user" and "content_blocks" in mns.list[-1] -%}
+            {%- set last = mns.list[-1] -%}
+            {%- set mns.list = mns.list[:-1] + [dict(last, content_blocks=last.content_blocks + [tblock])] -%}
+        {%- else -%}
+            {%- set mns.list = mns.list + [{"role": "user", "content_blocks": [tblock]}] -%}
+        {%- endif -%}
+    {%- elif msg.role == "user" -%}
+        {%- set text_block = {"type": "text", "text": msg.get("content", "")} -%}
+        {%- if mns.list|length > 0 and mns.list[-1].role == "user" and "content_blocks" in mns.list[-1] and mns.list[-1].get("task") is none -%}
+            {%- set last = mns.list[-1] -%}
+            {%- set mns.list = mns.list[:-1] + [dict(last, content_blocks=last.content_blocks + [text_block])] -%}
+        {%- else -%}
+            {%- set new_msg = {"role": "user", "content": msg.get("content", ""), "content_blocks": [text_block]} -%}
+            {%- if msg.get("task") is not none -%}
+                {%- set new_msg = dict(new_msg, task=msg.task) -%}
+            {%- endif -%}
+            {%- if msg.get("wo_eos") is not none -%}
+                {%- set new_msg = dict(new_msg, wo_eos=msg.wo_eos) -%}
+            {%- endif -%}
+            {%- set mns.list = mns.list + [new_msg] -%}
+        {%- endif -%}
+    {%- else -%}
+        {%- set mns.list = mns.list + [msg] -%}
+    {%- endif -%}
+{%- endfor -%}
+
+{%- if tools -%}
+    {%- set anchor_ns = namespace(found=false) -%}
+    {%- for m in mns.list -%}
+        {%- if m.role == "system" or m.role == "developer" -%}{%- set anchor_ns.found = true -%}{%- endif -%}
+    {%- endfor -%}
+    {%- if not anchor_ns.found -%}
+        {%- set mns.list = [{"role": "system", "content": ""}] + mns.list -%}
+    {%- endif -%}
+{%- endif -%}
+
+{%- set lu = namespace(idx=-1) -%}
+{%- for m in mns.list -%}
+    {%- if m.role == "user" or m.role == "developer" -%}
+        {%- set lu.idx = loop.index0 -%}
+    {%- endif -%}
+{%- endfor -%}
+
+{%- set fns = namespace(list=[], lu_idx=-1) -%}
+{%- if thinking_mode == "thinking" and effective_drop -%}
+    {%- for m in mns.list -%}
+        {%- if not (m.role == "developer" and loop.index0 < lu.idx) -%}
+            {%- if loop.index0 == lu.idx -%}{%- set fns.lu_idx = fns.list|length -%}{%- endif -%}
+            {%- set fns.list = fns.list + [m] -%}
+        {%- endif -%}
+    {%- endfor -%}
+{%- else -%}
+    {%- set fns.list = mns.list -%}
+    {%- set fns.lu_idx = lu.idx -%}
+{%- endif -%}
+
+{%- set att = namespace(idx=-1, sys=-1) -%}
+{%- if tools -%}
+    {%- for m in fns.list -%}
+        {%- if m.role == "developer" and att.idx == -1 -%}{%- set att.idx = loop.index0 -%}{%- endif -%}
+        {%- if m.role == "system" and att.sys == -1 -%}{%- set att.sys = loop.index0 -%}{%- endif -%}
+    {%- endfor -%}
+    {%- if att.idx == -1 -%}{%- set att.idx = att.sys -%}{%- endif -%}
+{%- endif -%}
+
+{{- "<｜begin▁of▁sentence｜>" -}}
+
+{%- if thinking_mode == "thinking" and reasoning_effort == "max" -%}
+{{- "Reasoning Effort: Absolute maximum with no shortcuts permitted.\nYou MUST be very thorough in your thinking and comprehensively decompose the problem to resolve the root cause, rigorously stress-testing your logic against all potential paths, edge cases, and adversarial scenarios.\nExplicitly write out your entire deliberation process, documenting every intermediate step, considered alternative, and rejected hypothesis to ensure absolutely no assumption is left unchecked.\n\n" -}}
+{%- endif -%}
+
+{%- for msg in fns.list -%}
+    {%- set idx = loop.index0 -%}
+    {%- set is_last = (idx == fns.list|length - 1) -%}
+    {%- set next_role = (fns.list[idx + 1].role) if (not is_last) else none -%}
+    {%- set prev_has_task = (idx > 0) and (fns.list[idx - 1].get("task") is not none) -%}
+
+    {%- set eff_tools = none -%}
+    {%- if msg.tools -%}{%- set eff_tools = msg.tools -%}
+    {%- elif idx == att.idx -%}{%- set eff_tools = tools -%}{%- endif -%}
+
+    {%- if msg.role == "system" or msg.role == "developer" -%}
+        {%- if msg.role == "developer" -%}{{- "<｜User｜>" -}}{%- endif -%}
+        {{- (msg.get("content", "") or "") -}}
+        {%- if eff_tools -%}{{- render_tools_block(eff_tools) -}}{%- endif -%}
+        {%- if msg.response_format is defined and msg.response_format -%}{{- render_response_format(msg.response_format) -}}{%- endif -%}
+
+    {%- elif msg.role == "user" -%}
+        {{- "<｜User｜>" -}}
+        {%- set parts_ns = namespace(parts=[]) -%}
+        {%- for b in msg.content_blocks -%}
+            {%- if b.type == "text" -%}
+                {%- set parts_ns.parts = parts_ns.parts + [b.get("text", "")] -%}
+            {%- elif b.type == "tool_result" -%}
+                {%- set tc_content = b.get("content", "") -%}
+                {%- if tc_content is iterable and tc_content is not string and tc_content is not mapping -%}
+                    {%- set txt_ns = namespace(texts=[]) -%}
+                    {%- for sub in tc_content -%}
+                        {%- if sub.type == "text" -%}
+                            {%- set txt_ns.texts = txt_ns.texts + [sub.get("text", "")] -%}
+                        {%- else -%}
+                            {%- set txt_ns.texts = txt_ns.texts + ["[Unsupported " ~ sub.type ~ "]"] -%}
+                        {%- endif -%}
+                    {%- endfor -%}
+                    {%- set tc_content = txt_ns.texts | join("\n\n") -%}
+                {%- endif -%}
+                {%- set parts_ns.parts = parts_ns.parts + ["<tool_result>" ~ tc_content ~ "</tool_result>"] -%}
+            {%- else -%}
+                {%- set parts_ns.parts = parts_ns.parts + ["[Unsupported " ~ b.type ~ "]"] -%}
+            {%- endif -%}
+        {%- endfor -%}
+        {{- parts_ns.parts | join("\n\n") -}}
+
+    {%- elif msg.role == "latest_reminder" -%}
+        {{- "<｜latest_reminder｜>" -}}{{- msg.content -}}
+
+    {%- elif msg.role == "assistant" -%}
+        {%- set rc = msg.get("reasoning_content", "") or "" -%}
+        {%- if (thinking_mode == "thinking") and (not prev_has_task) and ((not effective_drop) or idx > fns.lu_idx) -%}
+            {{- rc -}}{{- "</think>" -}}
+        {%- endif -%}
+        {{- msg.get("content", "") or "" -}}
+        {%- if msg.tool_calls -%}
+            {{- "\n\n<｜DSML｜tool_calls>\n" -}}
+            {%- set tc_ns = namespace(lines=[]) -%}
+            {%- for tc in msg.tool_calls -%}
+                {%- if tc.function is defined -%}
+                    {%- set tc_name = tc.function.name -%}{%- set tc_args = tc.function.arguments -%}
+                {%- else -%}
+                    {%- set tc_name = tc.name -%}{%- set tc_args = tc.arguments -%}
+                {%- endif -%}
+                {%- set p_ns = namespace(lines=[]) -%}
+                {%- if tc_args is mapping -%}
+                    {%- for key, value in tc_args.items() -%}
+                        {%- if value is string -%}
+                            {%- set p_ns.lines = p_ns.lines + ['<｜DSML｜parameter name="' ~ key ~ '" string="true">' ~ value ~ '</｜DSML｜parameter>'] -%}
+                        {%- else -%}
+                            {%- set p_ns.lines = p_ns.lines + ['<｜DSML｜parameter name="' ~ key ~ '" string="false">' ~ (value | tojson(ensure_ascii=false)) ~ '</｜DSML｜parameter>'] -%}
+                        {%- endif -%}
+                    {%- endfor -%}
+                {%- else -%}
+                    {%- set p_ns.lines = p_ns.lines + ['<｜DSML｜parameter name="arguments" string="true">' ~ (tc_args | string) ~ '</｜DSML｜parameter>'] -%}
+                {%- endif -%}
+                {%- set tc_ns.lines = tc_ns.lines + ['<｜DSML｜invoke name="' ~ tc_name ~ '">\n' ~ (p_ns.lines | join("\n")) ~ '\n</｜DSML｜invoke>'] -%}
+            {%- endfor -%}
+            {{- tc_ns.lines | join("\n") -}}{{- "\n</｜DSML｜tool_calls>" -}}
+        {%- endif -%}
+        {%- if not msg.get("wo_eos") -%}{{- "<｜end▁of▁sentence｜>" -}}{%- endif -%}
+
+    {%- else -%}
+        {{- raise_exception("Unknown role: " ~ msg.role) -}}
+    {%- endif -%}
+
+    {%- set need_transition = is_last or (next_role == "assistant") or (next_role == "latest_reminder") -%}
+    {%- set this_task = msg.get("task", none) -%}
+
+    {%- if need_transition and this_task is not none -%}
+        {%- set task_tokens = {"action": "<｜action｜>", "query": "<｜query｜>", "authority": "<｜authority｜>", "domain": "<｜domain｜>", "title": "<｜title｜>", "read_url": "<｜read_url｜>"} -%}
+        {%- if this_task not in task_tokens -%}{{- raise_exception("Invalid task: " ~ this_task) -}}{%- endif -%}
+        {%- if this_task == "action" -%}
+            {{- "<｜Assistant｜>" -}}{{- "<think>" if thinking_mode == "thinking" else "</think>" -}}
+        {%- endif -%}
+        {{- task_tokens[this_task] -}}
+    {%- elif need_transition and (msg.role == "user" or msg.role == "developer") and not (is_last and not add_generation_prompt) -%}
+        {{- "<｜Assistant｜>" -}}
+        {%- if thinking_mode == "thinking" -%}
+            {{- "<think>" if (not effective_drop) or idx >= fns.lu_idx else "</think>" -}}
+        {%- else -%}
+            {{- "</think>" -}}
+        {%- endif -%}
+    {%- endif -%}
+{%- endfor -%}

config.json

@@ -0,0 +1,76 @@
+{
+  "architectures": [
+    "DeepseekV4ForCausalLM"
+  ],
+  "attention_bias": true,
+  "attention_dropout": 0.0,
+  "bos_token_id": 0,
+  "eos_token_id": 1,
+  "expert_dtype": "fp4",
+  "hc_eps": 1e-06,
+  "hc_mult": 4,
+  "hc_sinkhorn_iters": 20,
+  "head_dim": 128,
+  "hidden_act": "silu",
+  "hidden_size": 128,
+  "index_head_dim": 128,
+  "index_n_heads": 4,
+  "index_topk": 1024,
+  "initializer_range": 0.02,
+  "max_position_embeddings": 1048576,
+  "model_type": "deepseek_v4",
+  "moe_intermediate_size": 128,
+  "n_routed_experts": 256,
+  "n_shared_experts": 1,
+  "norm_topk_prob": true,
+  "num_attention_heads": 4,
+  "num_experts_per_tok": 6,
+  "num_hidden_layers": 7,
+  "num_hash_layers": 3,
+  "num_key_value_heads": 1,
+  "num_nextn_predict_layers": 1,
+  "o_groups": 2,
+  "o_lora_rank": 128,
+  "q_lora_rank": 128,
+  "qk_rope_head_dim": 64,
+  "quantization_config": {
+    "activation_scheme": "dynamic",
+    "fmt": "e4m3",
+    "quant_method": "fp8",
+    "scale_fmt": "ue8m0",
+    "weight_block_size": [
+      128,
+      128
+    ]
+  },
+  "rms_norm_eps": 1e-06,
+  "rope_scaling": {
+    "beta_fast": 32,
+    "beta_slow": 1,
+    "factor": 16,
+    "original_max_position_embeddings": 65536,
+    "type": "yarn"
+  },
+  "rope_theta": 10000,
+  "routed_scaling_factor": 2.5,
+  "scoring_func": "sqrtsoftplus",
+  "sliding_window": 128,
+  "swiglu_limit": 10.0,
+  "tie_word_embeddings": false,
+  "topk_method": "noaux_tc",
+  "torch_dtype": "bfloat16",
+  "transformers_version": "4.57.1",
+  "use_cache": true,
+  "vocab_size": 129280,
+  "compress_rope_theta": 160000,
+  "compress_ratios": [
+    128,
+    128,
+    4,
+    128,
+    4,
+    128,
+    4,
+    0
+  ]
+}

generation_config.json

@@ -0,0 +1,9 @@
+{
+  "_from_model_config": true,
+  "bos_token_id": 0,
+  "do_sample": true,
+  "eos_token_id": 1,
+  "temperature": 1.0,
+  "top_p": 1.0,
+  "transformers_version": "5.14.0.dev0"
+}

model.safetensors

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:6bb51a655eeb37fce67ffa08ce55536613c967db1fb591a57d79630280ac7e00
+size 144491198

tokenizer_config.json

@@ -0,0 +1,14 @@
+{
+  "backend": "tokenizers",
+  "bos_token": "<｜begin▁of▁sentence｜>",
+  "clean_up_tokenization_spaces": false,
+  "eos_token": "<｜end▁of▁sentence｜>",
+  "is_local": false,
+  "legacy": true,
+  "local_files_only": false,
+  "model_max_length": 1048576,
+  "pad_token": "<｜end▁of▁sentence｜>",
+  "sp_model_kwargs": {},
+  "tokenizer_class": "TokenizersBackend",
+  "unk_token": null
+}