Upload folder using huggingface_hub

.gitattributes

@@ -33,3 +33,4 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.zip filter=lfs diff=lfs merge=lfs -text
 *.zst filter=lfs diff=lfs merge=lfs -text
 *tfevents* filter=lfs diff=lfs merge=lfs -text
+tokenizer.json filter=lfs diff=lfs merge=lfs -text

.meta.json

@@ -0,0 +1,22 @@
+{
+  "source_model": {
+    "name": "zai-org/GLM-5.3-Flash",
+    "commit_id": "46a050bec13002ad29ee795c16e61cf4fa3c4a9c"
+  },
+  "env": {
+    "python": "3.12.13",
+    "packages": {
+      "Pillow": "12.3.0",
+      "accelerate": "1.13.0",
+      "huggingface_hub": "2.3.0",
+      "kernels": "0.17.2",
+      "numpy": "2.5.2",
+      "safetensors": "0.8.0",
+      "tokenizers": "0.23.3",
+      "torch": "2.13.0+cu126",
+      "transformers": "5.20.2",
+      "vllm": "0.1.dev1+g5a3eba034.d20260730.cu126"
+    },
+    "cuda": "12.6"
+  }
+}

LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Z.AI Co., Ltd
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

README.md

@@ -0,0 +1,496 @@
+---
+library_name: transformers
+base_model:
+- zai-org/GLM-5.3-Flash
+---
+
+This tiny model is intended for debugging. It is randomly initialized using the configuration adapted from [zai-org/GLM-5.3-Flash](https://huggingface.co/zai-org/GLM-5.3-Flash).
+
+Structural comparison with `zai-org/GLM-5.3-Flash`:
+
+| Feature | Source | Tiny |
+|---|---:|---:|
+| Architecture / modalities | GLM5-Next; text, image, video | Same |
+| Vocabulary rows / tied embeddings | 154,880 / false | Same |
+| Text layers / attention cadence | 45; three KDA then DSA | 8; two complete three-KDA + DSA cycles |
+| Text hidden size | 4,096 | 128 |
+| KDA heads / head dimension | 64 / 128 | 64 / 128 |
+| DSA heads / NoPE / value dimensions | 64 / 256 / 256 | 64 / 32 / 256 |
+| Indexer heads / dimension / top-k | 32 / 128 / 2,048 | 32 / 128 / 128 |
+| Routed experts / selected experts / shared experts | 288 / 8 / 1 | 32 / 8 / 1 |
+| Hyper-Connections | Four manifold-constrained streams | Same |
+| MTP | One DSA/MoE layer with shared embedding/head | Same |
+| Vision depth / hidden / output size | 24 / 1,024 / 4,096 | 2 / 128 / 128 |
+| Checkpoint precision | BF16 plus E4M3 block-FP8 and FP32 scales | Same; 32x32 blocks for reduced axes |
+
+The KDA and DSA indexer heads remain 128-wide because vLLM's GLM5-Next KDA and Hadamard-128 indexer kernels require that ABI. The source E4M3 format is retained with reduced 32x32 blocks; the TP=4 example selects vLLM's Triton block-FP8 GEMM because H20's automatic Humming kernel requires an output scale group of at least 64.
+Tokenizer, processor, chat template and generation assets are copied unchanged from the pinned source revision.
+
+| File path | Size |
+|------|------|
+| model.safetensors | 207.3MB |
+
+
+### Example usage:
+
+- vLLM (✅ verified)
+
+```bash
+vllm serve tiny-random/glm-5.3-flash \
+  --tensor-parallel-size 4 \
+  --speculative-config '{"method":"mtp","num_speculative_tokens":1}' \
+  --max-model-len 4096 \
+  --max-num-batched-tokens 512 \
+  --max-num-seqs 4 \
+  --gpu-memory-utilization 0.3 \
+  --kernel-config '{"moe_backend":"triton","linear_backend":"triton"}' \
+  --compilation-config '{"cudagraph_capture_sizes":[1,2,4,8]}'
+```
+
+- Transformers (✅ verified)
+
+```python
+import numpy as np
+import torch
+from PIL import Image
+from transformers import AutoModelForImageTextToText, AutoProcessor
+from transformers.integrations.hub_kernels import allow_all_hub_kernels
+from transformers.video_utils import VideoMetadata
+
+model_id = "tiny-random/glm-5.3-flash"
+# Transformers resolves the official fine-grained FP8 kernel from the Hub.
+with allow_all_hub_kernels():
+    model = AutoModelForImageTextToText.from_pretrained(
+        model_id, dtype=torch.bfloat16, attn_implementation="sdpa",
+    ).to("cuda")
+    processor = AutoProcessor.from_pretrained(model_id)
+    image = Image.new("RGB", (28, 28), "red")
+    video = np.stack([
+        np.asarray(Image.new("RGB", (28, 28), color))
+        for color in ("red", "green", "blue", "yellow")
+    ])
+    messages = [{"role": "user", "content": [
+        {"type": "image", "image": image},
+        {"type": "video", "video": video},
+        {"type": "text", "text": "Describe the image and the video."},
+    ]}]
+    inputs = processor.apply_chat_template(
+        messages, tokenize=True, add_generation_prompt=True, return_dict=True, return_tensors="pt",
+        video_metadata=[VideoMetadata(total_num_frames=4, fps=2, frames_indices=[0, 1, 2, 3])],
+    ).to(model.device)
+    output = model.generate(**inputs, do_sample=False, max_new_tokens=10)
+print(processor.decode(output[0, inputs["input_ids"].shape[1]:], skip_special_tokens=True))
+```
+
+### Codes to create this repo (✅ verified):
+
+<details><summary>Click to expand</summary>
+
+```python
+"""Create the GLM5-Next multimodal checkpoint in its public FP8 schema."""
+import json
+from pathlib import Path
+from shutil import copyfile
+
+import torch
+from huggingface_hub import hf_hub_download, list_repo_files
+from safetensors.torch import save_file
+from transformers import AutoConfig, AutoModelForImageTextToText, set_seed
+
+source_model_id = "zai-org/GLM-5.3-Flash"
+save_folder = "/tmp/tiny-random/glm-53-flash"
+source_revision = "46a050bec13002ad29ee795c16e61cf4fa3c4a9c"
+set_seed(42)
+folder = Path(save_folder)
+folder.mkdir(parents=True, exist_ok=True)
+raw = json.loads(Path(hf_hub_download(
+    source_model_id, "config.json", revision=source_revision)).read_text())
+raw["quantization_config"]["weight_block_size"] = [32, 32]
+text = raw["text_config"]
+text.update(
+    hidden_size=128,
+    num_hidden_layers=8,
+    # Retain the source's TP=4-friendly global head topology. The KDA
+    # and DSA runtime kernels operate on 16 heads per TP rank.
+    num_attention_heads=64,
+    num_key_value_heads=64,
+    intermediate_size=128,
+    moe_intermediate_size=128,
+    n_routed_experts=32,
+    num_experts_per_tok=8,
+    q_lora_rank=128,
+    # FA3 sparse-MQA uses this latent as q_v and requires >=256.
+    kv_lora_rank=256,
+    qk_nope_head_dim=32,
+    qk_rope_head_dim=0,
+    # Retain source value-head width required by sparse-MQA FA3.
+    v_head_dim=256,
+    index_head_dim=128,
+    # The Hadamard-128 indexer fused kernel accepts 32 or 64; source is 32.
+    index_n_heads=32,
+    index_topk=128,
+    index_kpool=4,
+    linear_head_dim=128,
+    first_k_dense_replace=3,
+    layer_types=["linear_attention", "linear_attention", "linear_attention", "indexed_attention"] * 2,
+    mlp_layer_types=["dense", "dense", "dense", "sparse", "sparse", "sparse", "sparse", "sparse"],
+    indexer_types=["full"] * 8,
+)
+text["linear_attn_config"].update(
+    head_dim=128,
+    num_heads=64,
+    kda_layers=[0, 1, 2, 4, 5, 6],
+    full_attn_layers=[3, 7],
+)
+# TP=4 shards vision attention too: retain four visual heads and a
+# 32-wide visual head dimension for an executable multimodal tower.
+raw["vision_config"].update(
+    depth=2, hidden_size=128, intermediate_size=256, num_heads=4,
+    out_hidden_size=128, projection_intermediate_size=64, image_size=28, patch_size=14,
+)
+
+config_for_build = dict(raw)
+config_for_build.pop("quantization_config")
+(folder / "config.json").write_text(json.dumps(config_for_build, indent=2) + "\n")
+config = AutoConfig.from_pretrained(folder)
+model = AutoModelForImageTextToText.from_config(config, dtype=torch.bfloat16)
+
+with torch.no_grad():
+    for name, value in model.named_parameters():
+        if name.endswith("A_log"):
+            value.zero_()
+        elif name.endswith("dt_bias"):
+            value.fill_(1)
+        elif name.endswith("e_score_correction_bias"):
+            value.zero_()
+        elif name.endswith("weight") and "norm" in name:
+            value.fill_(1)
+        else:
+            value.normal_(mean=0.0, std=0.02)
+
+state = {name: value.detach().cpu().contiguous() for name, value in model.state_dict().items()}
+
+# Transformers builds the published GLM5-Next graph with convenient
+# module names (``attn_hc`` / ``forget_gate`` / fused ``conv1d``), while
+# both the pinned source checkpoint and vLLM consume the public checkpoint
+# schema below.  Convert it before quantization: this is a lossless key
+# rewrite except for splitting the concatenated Q|K|V convolution weight.
+for name in list(state):
+    replacement = (
+        name.replace(".attn_hc.base", ".hc_attn_base")
+        .replace(".attn_hc.fn", ".hc_attn_fn")
+        .replace(".attn_hc.scale", ".hc_attn_scale")
+        .replace(".ffn_hc.base", ".hc_ffn_base")
+        .replace(".ffn_hc.fn", ".hc_ffn_fn")
+        .replace(".ffn_hc.scale", ".hc_ffn_scale")
+        .replace(".self_attn.forget_gate.", ".self_attn.")
+    )
+    if replacement != name:
+        state[replacement] = state.pop(name)
+projection_size = text["linear_attn_config"]["num_heads"] * text["linear_attn_config"]["head_dim"]
+for name in list(state):
+    if not name.endswith(".self_attn.conv1d.weight"):
+        continue
+    prefix = name.removesuffix(".conv1d.weight")
+    q, k, v = state.pop(name).split(projection_size, dim=0)
+    state[prefix + ".q_conv1d.weight"] = q.contiguous()
+    state[prefix + ".k_conv1d.weight"] = k.contiguous()
+    state[prefix + ".v_conv1d.weight"] = v.contiguous()
+block_out, block_in = raw["quantization_config"]["weight_block_size"]
+
+def pack(name: str, weight: torch.Tensor) -> None:
+    rows, columns = weight.shape
+    assert rows % block_out == 0 and columns % block_in == 0, (name, weight.shape)
+    blocks = weight.float().reshape(rows // block_out, block_out, columns // block_in, block_in)
+    scales = (blocks.abs().amax(dim=(1, 3)) / 448).clamp_min(1e-12).to(torch.float32)
+    state[name] = (blocks / scales[:, None, :, None]).clamp(-448, 448).reshape(weight.shape).to(
+        torch.float8_e4m3fn
+    ).contiguous()
+    state[name.removesuffix("weight") + "weight_scale_inv"] = scales.contiguous()
+
+def keep_bf16(name: str) -> bool:
+    # GLM5-Next keeps every KDA/linear-attention tensor in BF16.  They are
+    # exposed below ``self_attn`` in the Transformers graph rather than
+    # under a ``linear_attention`` component name.
+    kda_prefixes = tuple(
+        f"model.language_model.layers.{index}.self_attn."
+        for index in (0, 1, 2, 4, 5, 6)
+    )
+    return (
+        name in {"model.language_model.embed_tokens.weight", "lm_head.weight"}
+        or name.startswith(kda_prefixes)
+        # GLM5-Next's DSA value expansion deliberately remains BF16.
+        or name.endswith(".self_attn.kv_b_proj.weight")
+        or ".norm." in name
+        or ".indexer." in name
+        or ".linear_attention." in name
+        or name.endswith(".mlp.gate.weight")
+        or name.endswith(".mlp.gate.e_score_correction_bias")
+        or name.startswith("model.visual.")
+    )
+
+# The upstream skip list contains absolute source-layer paths.  Retain
+# only the reduced graph's BF16 components so the Transformers FP8 loader
+# constructs KDA, DSA value, router, indexer and vision modules correctly.
+exclusions = {"model.language_model.embed_tokens", "lm_head", "model.visual"}
+for module_name, module in model.named_modules():
+    if isinstance(module, torch.nn.Linear) and keep_bf16(module_name + ".weight"):
+        exclusions.add(module_name)
+raw["quantization_config"]["modules_to_not_convert"] = sorted(exclusions)
+
+for name in list(state):
+    if not name.endswith(".mlp.experts.gate_up_proj"):
+        continue
+    prefix = name.removesuffix(".gate_up_proj")
+    gate_up = state.pop(name)
+    down = state.pop(prefix + ".down_proj")
+    for expert in range(gate_up.shape[0]):
+        gate, up = gate_up[expert].chunk(2, dim=0)
+        pack(f"{prefix}.{expert}.gate_proj.weight", gate)
+        pack(f"{prefix}.{expert}.up_proj.weight", up)
+        pack(f"{prefix}.{expert}.down_proj.weight", down[expert])
+
+for name in list(state):
+    value = state[name]
+    if not (name.endswith(".weight") and value.ndim == 2) or keep_bf16(name):
+        continue
+    pack(name, value)
+
+# vLLM consumes the next-token predictor from layer index num_hidden_layers.
+# It is a DSA/MoE layer, not a KDA/mHC layer, and shares the global token
+# embedding and LM head exactly like the source checkpoint.
+base_prefix = "model.language_model.layers.7."
+mtp_prefix = "model.language_model.layers.8."
+for name, value in list(state.items()):
+    # GLM5-Next's embedded draft DSA/MoE layer has no Hyper-Connections;
+    # source layer 45 likewise omits every hc_* tensor.
+    if name.startswith(base_prefix) and ".hc_" not in name:
+        state[mtp_prefix + name.removeprefix(base_prefix)] = value.clone()
+state[mtp_prefix + "eh_proj.weight"] = torch.empty(128, 256, dtype=torch.bfloat16).normal_(0, 0.02)
+for name in ("enorm.weight", "hnorm.weight", "shared_head.norm.weight"):
+    state[mtp_prefix + name] = torch.ones(128, dtype=torch.bfloat16)
+
+save_file(state, folder / "model.safetensors", metadata={"format": "pt"})
+(folder / "config.json").write_text(json.dumps(raw, indent=2) + "\n")
+
+assets = {
+    "tokenizer.json", "tokenizer_config.json", "special_tokens_map.json", "added_tokens.json",
+    "chat_template.jinja", "chat_template.json", "processor_config.json", "preprocessor_config.json",
+    "video_preprocessor_config.json", "generation_config.json", "LICENSE",
+}
+for name in sorted(set(list_repo_files(source_model_id, revision=source_revision)) & assets):
+    copyfile(hf_hub_download(source_model_id, name, revision=source_revision), folder / name)
+```
+
+</details>
+
+### Printing the model:
+
+<details><summary>Click to expand</summary>
+
+```text
+Glm5NextForConditionalGeneration(
+  (model): Glm5NextModel(
+    (visual): Glm5NextVisionModel(
+      (patch_embed): Glm5NextVisionPatchEmbed(
+        (proj): Conv3d(3, 128, kernel_size=(2, 14, 14), stride=(2, 14, 14))
+      )
+      (rotary_pos_emb): Glm5NextVisionRotaryEmbedding()
+      (blocks): ModuleList(
+        (0-1): 2 x Glm5NextVisionBlock(
+          (norm1): Glm5NextRMSNorm((128,), eps=1e-05)
+          (norm2): Glm5NextRMSNorm((128,), eps=1e-05)
+          (attn): Glm5NextVisionAttention(
+            (qkv): Linear(in_features=128, out_features=384, bias=True)
+            (proj): Linear(in_features=128, out_features=128, bias=True)
+            (q_norm): Glm5NextRMSNorm((32,), eps=1e-05)
+            (k_norm): Glm5NextRMSNorm((32,), eps=1e-05)
+          )
+          (mlp): Glm5NextVisionMLP(
+            (gate_proj): Linear(in_features=128, out_features=256, bias=True)
+            (up_proj): Linear(in_features=128, out_features=256, bias=True)
+            (down_proj): Linear(in_features=256, out_features=128, bias=True)
+            (act_fn): SiLUActivation()
+          )
+        )
+      )
+      (merger): Glm5NextVisionPatchMerger(
+        (proj): Linear(in_features=128, out_features=128, bias=False)
+        (post_projection_norm): LayerNorm((128,), eps=1e-05, elementwise_affine=True, bias=True)
+        (gate_proj): Linear(in_features=128, out_features=64, bias=False)
+        (up_proj): Linear(in_features=128, out_features=64, bias=False)
+        (down_proj): Linear(in_features=64, out_features=128, bias=False)
+        (act1): GELU(approximate='none')
+        (act_fn): SiLUActivation()
+      )
+      (downsample): Conv2d(128, 128, kernel_size=(2, 2), stride=(2, 2))
+      (post_layernorm): Glm5NextRMSNorm((128,), eps=1e-05)
+    )
+    (language_model): Glm5NextTextModel(
+      (embed_tokens): Embedding(154880, 128, padding_idx=154820)
+      (layers): ModuleList(
+        (0-2): 3 x Glm5NextTextDecoderLayer(
+          (self_attn): Glm5NextTextLinearAttention(
+            (q_proj): Linear(in_features=128, out_features=8192, bias=False)
+            (k_proj): Linear(in_features=128, out_features=8192, bias=False)
+            (v_proj): Linear(in_features=128, out_features=8192, bias=False)
+            (conv1d): Conv1d(24576, 24576, kernel_size=(4,), stride=(1,), padding=(3,), groups=24576, bias=False)
+            (forget_gate): Glm5NextTextForgetGate(
+              (f_a_proj): Linear(in_features=128, out_features=128, bias=False)
+              (f_b_proj): Linear(in_features=128, out_features=8192, bias=False)
+            )
+            (b_proj): Linear(in_features=128, out_features=64, bias=False)
+            (g_a_proj): Linear(in_features=128, out_features=128, bias=False)
+            (g_b_proj): Linear(in_features=128, out_features=8192, bias=False)
+            (o_norm): Glm5NextTextRMSNormGated()
+            (o_proj): Linear(in_features=8192, out_features=128, bias=False)
+          )
+          (mlp): Glm5NextTextMLP(
+            (gate_proj): Linear(in_features=128, out_features=128, bias=False)
+            (up_proj): Linear(in_features=128, out_features=128, bias=False)
+            (down_proj): Linear(in_features=128, out_features=128, bias=False)
+            (act_fn): SiLUActivation()
+          )
+          (input_layernorm): Glm5NextTextRMSNorm((128,), eps=1e-05)
+          (post_attention_layernorm): Glm5NextTextRMSNorm((128,), eps=1e-05)
+          (attn_hc): Glm5NextTextHyperConnection(
+            (input_norm): Glm5NextTextUnweightedRMSNorm()
+          )
+          (ffn_hc): Glm5NextTextHyperConnection(
+            (input_norm): Glm5NextTextUnweightedRMSNorm()
+          )
+        )
+        (3): Glm5NextTextDecoderLayer(
+          (self_attn): Glm5NextTextAttention(
+            (q_a_proj): Linear(in_features=128, out_features=128, bias=False)
+            (q_a_layernorm): Glm5NextTextRMSNorm((128,), eps=1e-05)
+            (q_b_proj): Linear(in_features=128, out_features=2048, bias=False)
+            (kv_a_proj_with_mqa): Linear(in_features=128, out_features=256, bias=False)
+            (kv_a_layernorm): Glm5NextTextRMSNorm((256,), eps=1e-05)
+            (kv_b_proj): Linear(in_features=256, out_features=18432, bias=False)
+            (o_proj): Linear(in_features=16384, out_features=128, bias=False)
+            (indexer): Glm5NextTextIndexer(
+              (wq_b): Linear(in_features=128, out_features=4096, bias=False)
+              (wk): Linear(in_features=128, out_features=128, bias=False)
+              (k_norm): LayerNorm((128,), eps=1e-06, elementwise_affine=True, bias=True)
+              (weights_proj): Linear(in_features=128, out_features=32, bias=False)
+            )
+          )
+          (mlp): Glm5NextTextMoE(
+            (experts): Glm5NextTextExperts()
+            (gate): Glm5NextTextTopkRouter()
+            (shared_experts): Glm5NextTextMLP(
+              (gate_proj): Linear(in_features=128, out_features=128, bias=False)
+              (up_proj): Linear(in_features=128, out_features=128, bias=False)
+              (down_proj): Linear(in_features=128, out_features=128, bias=False)
+              (act_fn): SiLUActivation()
+            )
+          )
+          (input_layernorm): Glm5NextTextRMSNorm((128,), eps=1e-05)
+          (post_attention_layernorm): Glm5NextTextRMSNorm((128,), eps=1e-05)
+          (attn_hc): Glm5NextTextHyperConnection(
+            (input_norm): Glm5NextTextUnweightedRMSNorm()
+          )
+          (ffn_hc): Glm5NextTextHyperConnection(
+            (input_norm): Glm5NextTextUnweightedRMSNorm()
+          )
+        )
+        (4-6): 3 x Glm5NextTextDecoderLayer(
+          (self_attn): Glm5NextTextLinearAttention(
+            (q_proj): Linear(in_features=128, out_features=8192, bias=False)
+            (k_proj): Linear(in_features=128, out_features=8192, bias=False)
+            (v_proj): Linear(in_features=128, out_features=8192, bias=False)
+            (conv1d): Conv1d(24576, 24576, kernel_size=(4,), stride=(1,), padding=(3,), groups=24576, bias=False)
+            (forget_gate): Glm5NextTextForgetGate(
+              (f_a_proj): Linear(in_features=128, out_features=128, bias=False)
+              (f_b_proj): Linear(in_features=128, out_features=8192, bias=False)
+            )
+            (b_proj): Linear(in_features=128, out_features=64, bias=False)
+            (g_a_proj): Linear(in_features=128, out_features=128, bias=False)
+            (g_b_proj): Linear(in_features=128, out_features=8192, bias=False)
+            (o_norm): Glm5NextTextRMSNormGated()
+            (o_proj): Linear(in_features=8192, out_features=128, bias=False)
+          )
+          (mlp): Glm5NextTextMoE(
+            (experts): Glm5NextTextExperts()
+            (gate): Glm5NextTextTopkRouter()
+            (shared_experts): Glm5NextTextMLP(
+              (gate_proj): Linear(in_features=128, out_features=128, bias=False)
+              (up_proj): Linear(in_features=128, out_features=128, bias=False)
+              (down_proj): Linear(in_features=128, out_features=128, bias=False)
+              (act_fn): SiLUActivation()
+            )
+          )
+          (input_layernorm): Glm5NextTextRMSNorm((128,), eps=1e-05)
+          (post_attention_layernorm): Glm5NextTextRMSNorm((128,), eps=1e-05)
+          (attn_hc): Glm5NextTextHyperConnection(
+            (input_norm): Glm5NextTextUnweightedRMSNorm()
+          )
+          (ffn_hc): Glm5NextTextHyperConnection(
+            (input_norm): Glm5NextTextUnweightedRMSNorm()
+          )
+        )
+        (7): Glm5NextTextDecoderLayer(
+          (self_attn): Glm5NextTextAttention(
+            (q_a_proj): Linear(in_features=128, out_features=128, bias=False)
+            (q_a_layernorm): Glm5NextTextRMSNorm((128,), eps=1e-05)
+            (q_b_proj): Linear(in_features=128, out_features=2048, bias=False)
+            (kv_a_proj_with_mqa): Linear(in_features=128, out_features=256, bias=False)
+            (kv_a_layernorm): Glm5NextTextRMSNorm((256,), eps=1e-05)
+            (kv_b_proj): Linear(in_features=256, out_features=18432, bias=False)
+            (o_proj): Linear(in_features=16384, out_features=128, bias=False)
+            (indexer): Glm5NextTextIndexer(
+              (wq_b): Linear(in_features=128, out_features=4096, bias=False)
+              (wk): Linear(in_features=128, out_features=128, bias=False)
+              (k_norm): LayerNorm((128,), eps=1e-06, elementwise_affine=True, bias=True)
+              (weights_proj): Linear(in_features=128, out_features=32, bias=False)
+            )
+          )
+          (mlp): Glm5NextTextMoE(
+            (experts): Glm5NextTextExperts()
+            (gate): Glm5NextTextTopkRouter()
+            (shared_experts): Glm5NextTextMLP(
+              (gate_proj): Linear(in_features=128, out_features=128, bias=False)
+              (up_proj): Linear(in_features=128, out_features=128, bias=False)
+              (down_proj): Linear(in_features=128, out_features=128, bias=False)
+              (act_fn): SiLUActivation()
+            )
+          )
+          (input_layernorm): Glm5NextTextRMSNorm((128,), eps=1e-05)
+          (post_attention_layernorm): Glm5NextTextRMSNorm((128,), eps=1e-05)
+          (attn_hc): Glm5NextTextHyperConnection(
+            (input_norm): Glm5NextTextUnweightedRMSNorm()
+          )
+          (ffn_hc): Glm5NextTextHyperConnection(
+            (input_norm): Glm5NextTextUnweightedRMSNorm()
+          )
+        )
+      )
+      (norm): Glm5NextTextRMSNorm((128,), eps=1e-05)
+      (hc_head): Glm5NextTextHyperHead()
+    )
+  )
+  (lm_head): Linear(in_features=128, out_features=154880, bias=False)
+)
+```
+
+</details>
+
+### Test environment:
+
+- Pillow: 12.3.0
+- accelerate: 1.13.0
+- huggingface_hub: 2.3.0
+- kernels: 0.17.2
+- numpy: 2.5.2
+- safetensors: 0.8.0
+- tokenizers: 0.23.3
+- torch: 2.13.0+cu126
+- transformers: 5.20.2
+- vllm: 0.1.dev1+g5a3eba034.d20260730.cu126
+
+### Change log:
+
+- 2026-10-24: Initial version.
+
+This repo is generated by GPT-6.1-Sol

chat_template.jinja

@@ -0,0 +1,257 @@
+[gMASK]<sop>
+{%- set effective_reasoning_effort = reasoning_effort if reasoning_effort is defined and reasoning_effort in ['low', 'high'] else 'max' -%}
+{%- if effective_reasoning_effort is not none -%}<|system|>Reasoning Effort: {{ effective_reasoning_effort | capitalize }}{%- endif -%}
+{%- set clear_thinking = clear_thinking if clear_thinking is defined else false -%}
+{%- if tools -%}
+{%- macro tool_to_json(tool) -%}
+    {%- set ns_tool = namespace(first=true) -%}
+    {{ '{' -}}
+    {%- for k, v in tool.items() -%}
+        {%- if k != 'defer_loading' and k != 'strict' -%}
+            {%- if not ns_tool.first -%}{{- ', ' -}}{%- endif -%}
+            {%- set ns_tool.first = false -%}
+            "{{ k }}": {{ v | tojson(ensure_ascii=False) }}
+        {%- endif -%}
+    {%- endfor -%}
+    {{- '}' -}}
+{%- endmacro -%}
+{%- macro tool_references_to_response(refs) -%}
+    {{- '<tool_response><tools>\n' -}}
+    {%- for tr in refs -%}
+        {%- for tool in tools -%}
+            {%- if 'function' in tool -%}
+                {%- set tool = tool['function'] -%}
+            {%- endif -%}
+            {%- if tool.name == tr.name -%}
+                {{- tool_to_json(tool) + '\n' -}}
+            {%- endif -%}
+        {%- endfor -%}
+    {%- endfor -%}
+    {{- '</tools></tool_response>' -}}
+{%- endmacro -%}
+<|system|>
+# Tools
+
+You may call one or more functions to assist with the user query.
+
+You are provided with function signatures within <tools></tools> XML tags:
+<tools>
+{% for tool in tools %}
+{%- if 'function' in tool -%}
+    {%- set tool = tool['function'] -%}
+{%- endif -%}
+{% if tool.defer_loading is not defined or not tool.defer_loading %}
+{{ tool_to_json(tool) }}
+{% endif %}
+{% endfor %}
+</tools>
+
+For each function call, output the function name and arguments within the following XML format:
+<tool_call>{function-name}<arg_key>{arg-key-1}</arg_key><arg_value>{arg-value-1}</arg_value><arg_key>{arg-key-2}</arg_key><arg_value>{arg-value-2}</arg_value>...</tool_call>{%- endif -%}
+{%- macro emit_image() -%}<|begin_of_image|><|image|><|end_of_image|>{%- endmacro -%}
+{%- macro emit_video() -%}<|begin_of_video|><|video|><|end_of_video|>{%- endmacro -%}
+{%- macro emit_audio() -%}<|begin_of_audio|><|end_of_audio|>{%- endmacro -%}
+{%- macro visible_text(content) -%}
+    {%- if content is string -%}
+        {{- content -}}
+    {%- elif content is iterable and content is not mapping -%}
+        {%- for item in content -%}
+            {%- if item is mapping and item.type == 'text' -%}
+                {{- item.text -}}
+            {%- elif item is string -%}
+                {{- item -}}
+            {%- elif item is mapping and item.type in ['image', 'image_url'] -%}
+                {{- emit_image() -}}
+            {%- elif item is mapping and item.type in ['video', 'video_url'] -%}
+                {{- emit_video() -}}
+            {%- elif item is mapping and item.type in ['audio', 'audio_url', 'input_audio'] -%}
+                {{- emit_audio() -}}
+            {%- endif -%}
+        {%- endfor -%}
+    {%- elif content is not none -%}
+        {{- content -}}
+    {%- endif -%}
+{%- endmacro -%}
+{%- macro tool_response(text) -%}
+{{- '<tool_response>' + text + '</tool_response>' -}}
+{%- endmacro -%}
+{%- macro render_tool_response(m) -%}
+{%- if m.content is string -%}
+    {{- tool_response(m.content) -}}
+{%- elif m.content and m.content is not mapping and m.content.0.type == "tool_reference" -%}
+    {{- tool_references_to_response(m.content) -}}
+{%- elif is_list_of_outputs(m) -%}
+    {%- for tr in m.content -%}
+        {%- if tr.output is iterable and tr.output is not string and tr.output is not mapping and tr.output and tr.output.0.type == "tool_reference" -%}
+            {{- tool_references_to_response(tr.output) -}}
+        {%- else -%}
+            {{- tool_response(visible_text(tr.output)) -}}
+        {%- endif -%}
+    {%- endfor -%}
+{%- else -%}
+    {{- tool_response(visible_text(m.content)) -}}
+{%- endif -%}
+{%- endmacro -%}
+{%- macro id_of(obj) -%}
+    {%- if obj.tool_call_id -%}
+        {{- obj.tool_call_id -}}
+    {%- elif obj.id -%}
+        {{- obj.id -}}
+    {%- endif -%}
+{%- endmacro -%}
+{%- macro is_list_of_outputs(m) -%}
+    {%- if m.content and m.content.0.output is defined -%}1{%- endif -%}
+{%- endmacro -%}
+{%- macro has_dup_tool_result_id(lo, hi, target) -%}
+    {%- set ns_cnt = namespace(n=0) -%}
+    {%- for k in range(lo, hi + 1) -%}
+        {%- set m = messages[k] -%}
+        {%- if is_list_of_outputs(m) -%}
+            {%- for entry in m.content -%}
+                {%- if id_of(entry) == target -%}
+                    {%- set ns_cnt.n = ns_cnt.n + 1 -%}
+                {%- endif -%}
+            {%- endfor -%}
+        {%- elif id_of(m) == target -%}
+            {%- set ns_cnt.n = ns_cnt.n + 1 -%}
+        {%- endif -%}
+        {%- if ns_cnt.n > 1 -%}{%- break -%}{%- endif -%}
+    {%- endfor -%}
+    {%- if ns_cnt.n > 1 -%}1{%- endif -%}
+{%- endmacro -%}
+{%- macro tc_id_exists(tcs, target) -%}
+    {%- set ns_f = namespace(found=false) -%}
+    {%- for tc in tcs -%}
+        {%- if id_of(tc) == target -%}
+            {%- set ns_f.found = true -%}
+            {%- break -%}
+        {%- endif -%}
+    {%- endfor -%}
+    {%- if ns_f.found -%}1{%- endif -%}
+{%- endmacro -%}
+{%- set ns = namespace(last_user_index=-1) -%}
+{%- for m in messages %}
+    {%- if m.role == 'user' %}
+        {%- set ns.last_user_index = loop.index0 -%}
+    {%- endif %}
+{%- endfor %}
+{%- for m in messages -%}
+{%- if m.role == 'user' -%}<|user|>{{ visible_text(m.content) }}
+{%- elif m.role == 'assistant' -%}
+<|assistant|>
+{%- set content = visible_text(m.content) %}
+{%- if m.reasoning_content is string %}
+    {%- set reasoning_content = m.reasoning_content %}
+{%- elif '</think>' in content %}
+    {%- set reasoning_content = content.split('</think>')[0].split('<think>')[-1] %}
+    {%- set content = content.split('</think>')[-1] %}
+{%- endif %}
+{%- if (not clear_thinking or loop.index0 > ns.last_user_index) and reasoning_content is defined -%}
+{{ '<think>' + reasoning_content +  '</think>'}}
+{%- else -%}
+{{ '<think></think>' }}
+{%- endif -%}
+{%- if content.strip() -%}
+{{ content.strip() }}
+{%- endif -%}
+{% if m.tool_calls %}
+{% for tc in m.tool_calls %}
+{%- if tc.function %}
+    {%- set tc = tc.function %}
+{%- endif %}
+{{- '<tool_call>' ~ tc.name -}}
+{% set _args = tc.arguments %}{% for k, v in _args.items() %}<arg_key>{{ k }}</arg_key><arg_value>{{ v | tojson(ensure_ascii=False) if v is not string else v }}</arg_value>{% endfor %}</tool_call>{% endfor %}
+{% endif %}
+{%- elif m.role == 'tool' -%}
+{%- if loop.first or (messages[loop.index0 - 1].role != "tool") %}
+    {{- '<|observation|>' -}}
+    {%- set block_start = loop.index0 -%}
+    {%- set ns_blk = namespace(end=block_start) -%}
+    {%- for j in range(block_start, messages|length) -%}
+        {%- if messages[j].role == 'tool' -%}
+            {%- set ns_blk.end = j -%}
+        {%- else -%}
+            {%- break -%}
+        {%- endif -%}
+    {%- endfor -%}
+    {%- set ns_a = namespace(tool_calls=none) -%}
+    {%- if block_start > 0 and messages[block_start - 1].role == 'assistant' and messages[block_start - 1].tool_calls -%}
+        {%- set ns_a.tool_calls = messages[block_start - 1].tool_calls -%}
+    {%- endif -%}
+    {%- set ns_chk = namespace(can_sort=true, res=[], mk=[], ek=[], tcs=[]) -%}
+    {%- for k in range(block_start, ns_blk.end + 1) -%}
+        {%- set m = messages[k] -%}
+        {%- if is_list_of_outputs(m) -%}
+            {%- for entry in m.content -%}
+                {%- set ns_chk.res = ns_chk.res + [id_of(entry)] -%}
+                {%- set ns_chk.mk = ns_chk.mk + [k] -%}
+                {%- set ns_chk.ek = ns_chk.ek + [loop.index0] -%}
+            {%- endfor -%}
+        {%- else -%}
+            {%- set ns_chk.res = ns_chk.res + [id_of(m)] -%}
+            {%- set ns_chk.mk = ns_chk.mk + [k] -%}
+            {%- set ns_chk.ek = ns_chk.ek + [-1] -%}
+        {%- endif -%}
+    {%- endfor -%}
+    {%- if not ns_a.tool_calls -%}
+        {%- set ns_chk.can_sort = false -%}
+    {%- else -%}
+        {%- for tc in ns_a.tool_calls -%}
+            {%- set ns_chk.tcs = ns_chk.tcs + [id_of(tc)] -%}
+        {%- endfor -%}
+        {%- if '' in ns_chk.res or '' in ns_chk.tcs -%}
+            {%- set ns_chk.can_sort = false -%}
+        {%- elif ns_chk.res | unique(case_sensitive=true) | list | length != ns_chk.res | length -%}
+            {%- set ns_chk.can_sort = false -%}
+        {%- elif ns_chk.tcs | unique(case_sensitive=true) | list | length != ns_chk.tcs | length -%}
+            {%- set ns_chk.can_sort = false -%}
+        {%- else -%}
+            {%- for eid in ns_chk.res -%}
+                {%- if eid not in ns_chk.tcs -%}
+                    {%- set ns_chk.can_sort = false -%}
+                    {%- break -%}
+                {%- endif -%}
+            {%- endfor -%}
+        {%- endif -%}
+    {%- endif -%}
+    {%- if ns_chk.can_sort -%}
+        {%- set ns_ord = namespace(res=[], tcs=[], j=0, pairs=[]) -%}
+        {%- for eid in ns_chk.res -%}
+            {%- set ns_ord.res = ns_ord.res + [{'id': eid, 'p': loop.index0}] -%}
+        {%- endfor -%}
+        {%- for tc_id in ns_chk.tcs -%}
+            {%- set ns_ord.tcs = ns_ord.tcs + [{'id': tc_id, 'i': loop.index0}] -%}
+        {%- endfor -%}
+        {%- set ns_ord.res = ns_ord.res | sort(attribute='id', case_sensitive=true) -%}
+        {%- for tc in ns_ord.tcs | sort(attribute='id', case_sensitive=true) -%}
+            {%- if ns_ord.j < ns_ord.res | length and ns_ord.res[ns_ord.j].id == tc.id -%}
+                {%- set ns_ord.pairs = ns_ord.pairs + [{'i': tc.i, 'p': ns_ord.res[ns_ord.j].p}] -%}
+                {%- set ns_ord.j = ns_ord.j + 1 -%}
+            {%- endif -%}
+        {%- endfor -%}
+        {%- for pair in ns_ord.pairs | sort(attribute='i') -%}
+            {%- set m = messages[ns_chk.mk[pair.p]] -%}
+            {%- if ns_chk.ek[pair.p] >= 0 -%}
+                {%- set entry = m.content[ns_chk.ek[pair.p]] -%}
+                {%- if entry.output is iterable and entry.output is not string and entry.output is not mapping and entry.output and entry.output.0.type == "tool_reference" -%}
+                    {{- tool_references_to_response(entry.output) -}}
+                {%- else -%}
+                    {{- tool_response(visible_text(entry.output)) -}}
+                {%- endif -%}
+            {%- else -%}
+                {{- render_tool_response(m) -}}
+            {%- endif -%}
+        {%- endfor -%}
+    {%- else -%}
+        {%- for k in range(block_start, ns_blk.end + 1) -%}
+            {{- render_tool_response(messages[k]) -}}
+        {%- endfor -%}
+    {%- endif -%}
+{% endif -%}
+{%- elif m.role == 'system' -%}
+<|system|>{{ visible_text(m.content) }}
+{%- endif -%}
+{%- endfor -%}
+{%- if add_generation_prompt -%}
+    <|assistant|>{{- '<think>' -}}
+{%- endif -%}

config.json

@@ -0,0 +1,233 @@
+{
+  "architectures": [
+    "Glm5NextForConditionalGeneration"
+  ],
+  "text_config": {
+    "attention_bias": false,
+    "attention_dropout": 0.0,
+    "dtype": "bfloat16",
+    "eos_token_id": [
+      154820,
+      154827,
+      154829
+    ],
+    "first_k_dense_replace": 3,
+    "hc_eps": 1e-06,
+    "hc_mult": 4,
+    "hc_sinkhorn_iters": 20,
+    "head_dim": 0,
+    "hidden_act": "silu",
+    "hidden_size": 128,
+    "index_head_dim": 128,
+    "index_kpool": 4,
+    "index_kpool_always_select_tail": true,
+    "index_kpool_compress": true,
+    "index_n_heads": 32,
+    "index_topk": 128,
+    "index_share_for_mtp_iteration": true,
+    "indexer_rope_interleave": true,
+    "indexer_types": [
+      "full",
+      "full",
+      "full",
+      "full",
+      "full",
+      "full",
+      "full",
+      "full"
+    ],
+    "initializer_range": 0.02,
+    "intermediate_size": 128,
+    "kv_lora_rank": 256,
+    "layer_types": [
+      "linear_attention",
+      "linear_attention",
+      "linear_attention",
+      "indexed_attention",
+      "linear_attention",
+      "linear_attention",
+      "linear_attention",
+      "indexed_attention"
+    ],
+    "linear_attn_config": {
+      "num_heads": 64,
+      "gate_lower_bound": -5.0,
+      "head_dim": 128,
+      "short_conv_kernel_size": 4,
+      "kda_layers": [
+        0,
+        1,
+        2,
+        4,
+        5,
+        6
+      ],
+      "full_attn_layers": [
+        3,
+        7
+      ]
+    },
+    "max_position_embeddings": 1048576,
+    "mhc": true,
+    "mla_use_nope": true,
+    "mlp_layer_types": [
+      "dense",
+      "dense",
+      "dense",
+      "sparse",
+      "sparse",
+      "sparse",
+      "sparse",
+      "sparse"
+    ],
+    "model_type": "glm5_next_text",
+    "moe_intermediate_size": 128,
+    "moe_router_dtype": "float32",
+    "n_group": 1,
+    "n_routed_experts": 32,
+    "n_shared_experts": 1,
+    "norm_topk_prob": true,
+    "num_attention_heads": 64,
+    "num_experts_per_tok": 8,
+    "num_hidden_layers": 8,
+    "num_key_value_heads": 64,
+    "num_nextn_predict_layers": 1,
+    "output_router_logits": false,
+    "pad_token_id": 154820,
+    "q_lora_rank": 128,
+    "qk_head_dim": 256,
+    "qk_nope_head_dim": 32,
+    "qk_rope_head_dim": 0,
+    "rms_norm_eps": 1e-05,
+    "routed_scaling_factor": 2.5,
+    "router_aux_loss_coef": 0.001,
+    "scoring_func": "sigmoid",
+    "swiglu_limit": 10.0,
+    "tie_word_embeddings": false,
+    "topk_group": 1,
+    "topk_method": "noaux_tc",
+    "use_cache": true,
+    "v_head_dim": 256,
+    "vocab_size": 154880,
+    "linear_head_dim": 128
+  },
+  "vision_config": {
+    "attention_bias": true,
+    "attention_dropout": 0.0,
+    "depth": 2,
+    "hidden_act": "silu",
+    "hidden_size": 128,
+    "image_size": 28,
+    "in_channels": 3,
+    "initializer_range": 0.02,
+    "intermediate_size": 256,
+    "model_type": "glm5_next_vision",
+    "num_heads": 4,
+    "out_hidden_size": 128,
+    "patch_size": 14,
+    "projection_intermediate_size": 64,
+    "rms_norm_eps": 1e-05,
+    "spatial_merge_size": 2,
+    "swiglu_limit": 10.0,
+    "temporal_patch_size": 2
+  },
+  "image_token_id": 154854,
+  "video_token_id": 154855,
+  "image_start_token_id": 154830,
+  "image_end_token_id": 154831,
+  "video_start_token_id": 154832,
+  "video_end_token_id": 154833,
+  "tie_word_embeddings": false,
+  "model_type": "glm5_next",
+  "transformers_version": "5.16.0",
+  "quantization_config": {
+    "activation_scheme": "dynamic",
+    "fmt": "e4m3",
+    "modules_to_not_convert": [
+      "lm_head",
+      "model.language_model.embed_tokens",
+      "model.language_model.layers.0.self_attn.b_proj",
+      "model.language_model.layers.0.self_attn.forget_gate.f_a_proj",
+      "model.language_model.layers.0.self_attn.forget_gate.f_b_proj",
+      "model.language_model.layers.0.self_attn.g_a_proj",
+      "model.language_model.layers.0.self_attn.g_b_proj",
+      "model.language_model.layers.0.self_attn.k_proj",
+      "model.language_model.layers.0.self_attn.o_proj",
+      "model.language_model.layers.0.self_attn.q_proj",
+      "model.language_model.layers.0.self_attn.v_proj",
+      "model.language_model.layers.1.self_attn.b_proj",
+      "model.language_model.layers.1.self_attn.forget_gate.f_a_proj",
+      "model.language_model.layers.1.self_attn.forget_gate.f_b_proj",
+      "model.language_model.layers.1.self_attn.g_a_proj",
+      "model.language_model.layers.1.self_attn.g_b_proj",
+      "model.language_model.layers.1.self_attn.k_proj",
+      "model.language_model.layers.1.self_attn.o_proj",
+      "model.language_model.layers.1.self_attn.q_proj",
+      "model.language_model.layers.1.self_attn.v_proj",
+      "model.language_model.layers.2.self_attn.b_proj",
+      "model.language_model.layers.2.self_attn.forget_gate.f_a_proj",
+      "model.language_model.layers.2.self_attn.forget_gate.f_b_proj",
+      "model.language_model.layers.2.self_attn.g_a_proj",
+      "model.language_model.layers.2.self_attn.g_b_proj",
+      "model.language_model.layers.2.self_attn.k_proj",
+      "model.language_model.layers.2.self_attn.o_proj",
+      "model.language_model.layers.2.self_attn.q_proj",
+      "model.language_model.layers.2.self_attn.v_proj",
+      "model.language_model.layers.3.self_attn.indexer.weights_proj",
+      "model.language_model.layers.3.self_attn.indexer.wk",
+      "model.language_model.layers.3.self_attn.indexer.wq_b",
+      "model.language_model.layers.3.self_attn.kv_b_proj",
+      "model.language_model.layers.4.self_attn.b_proj",
+      "model.language_model.layers.4.self_attn.forget_gate.f_a_proj",
+      "model.language_model.layers.4.self_attn.forget_gate.f_b_proj",
+      "model.language_model.layers.4.self_attn.g_a_proj",
+      "model.language_model.layers.4.self_attn.g_b_proj",
+      "model.language_model.layers.4.self_attn.k_proj",
+      "model.language_model.layers.4.self_attn.o_proj",
+      "model.language_model.layers.4.self_attn.q_proj",
+      "model.language_model.layers.4.self_attn.v_proj",
+      "model.language_model.layers.5.self_attn.b_proj",
+      "model.language_model.layers.5.self_attn.forget_gate.f_a_proj",
+      "model.language_model.layers.5.self_attn.forget_gate.f_b_proj",
+      "model.language_model.layers.5.self_attn.g_a_proj",
+      "model.language_model.layers.5.self_attn.g_b_proj",
+      "model.language_model.layers.5.self_attn.k_proj",
+      "model.language_model.layers.5.self_attn.o_proj",
+      "model.language_model.layers.5.self_attn.q_proj",
+      "model.language_model.layers.5.self_attn.v_proj",
+      "model.language_model.layers.6.self_attn.b_proj",
+      "model.language_model.layers.6.self_attn.forget_gate.f_a_proj",
+      "model.language_model.layers.6.self_attn.forget_gate.f_b_proj",
+      "model.language_model.layers.6.self_attn.g_a_proj",
+      "model.language_model.layers.6.self_attn.g_b_proj",
+      "model.language_model.layers.6.self_attn.k_proj",
+      "model.language_model.layers.6.self_attn.o_proj",
+      "model.language_model.layers.6.self_attn.q_proj",
+      "model.language_model.layers.6.self_attn.v_proj",
+      "model.language_model.layers.7.self_attn.indexer.weights_proj",
+      "model.language_model.layers.7.self_attn.indexer.wk",
+      "model.language_model.layers.7.self_attn.indexer.wq_b",
+      "model.language_model.layers.7.self_attn.kv_b_proj",
+      "model.visual",
+      "model.visual.blocks.0.attn.proj",
+      "model.visual.blocks.0.attn.qkv",
+      "model.visual.blocks.0.mlp.down_proj",
+      "model.visual.blocks.0.mlp.gate_proj",
+      "model.visual.blocks.0.mlp.up_proj",
+      "model.visual.blocks.1.attn.proj",
+      "model.visual.blocks.1.attn.qkv",
+      "model.visual.blocks.1.mlp.down_proj",
+      "model.visual.blocks.1.mlp.gate_proj",
+      "model.visual.blocks.1.mlp.up_proj",
+      "model.visual.merger.down_proj",
+      "model.visual.merger.gate_proj",
+      "model.visual.merger.proj",
+      "model.visual.merger.up_proj"
+    ],
+    "quant_method": "fp8",
+    "weight_block_size": [
+      32,
+      32
+    ]
+  }
+}

generation_config.json

@@ -0,0 +1,12 @@
+{
+  "_from_model_config": true,
+  "eos_token_id": [
+    154820,
+    154827,
+    154829
+  ],
+  "pad_token_id": 154820,
+  "temperature": 1.0,
+  "top_p": 0.95,
+  "transformers_version": "5.16.0"
+}

model.safetensors

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

processor_config.json

@@ -0,0 +1,44 @@
+{
+  "image_processor": {
+    "do_rescale": true,
+    "patch_expand_factor": 1,
+    "merge_size": 2,
+    "image_mean": [
+      0.48145466,
+      0.4578275,
+      0.40821073
+    ],
+    "image_std": [
+      0.26862954,
+      0.26130258,
+      0.27577711
+    ],
+    "temporal_patch_size": 2,
+    "patch_size": 14,
+    "min_image_tokens": 16,
+    "max_image_tokens": 8000,
+    "image_processor_type": "Glm5NextImageProcessor"
+  },
+  "video_processor": {
+    "do_rescale": true,
+    "video_processor_type": "Glm5NextVideoProcessor",
+    "patch_expand_factor": 1,
+    "merge_size": 2,
+    "image_mean": [
+      0.48145466,
+      0.4578275,
+      0.40821073
+    ],
+    "image_std": [
+      0.26862954,
+      0.26130258,
+      0.27577711
+    ],
+    "temporal_patch_size": 2,
+    "patch_size": 14,
+    "min_image_tokens": 16,
+    "max_image_tokens": 240000,
+    "fps": 2
+  },
+  "processor_class": "Glm5NextProcessor"
+}

tokenizer.json

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:19e773648cb4e65de8660ea6365e10acca112d42a854923df93db4a6f333a82d
+size 20217442

tokenizer_config.json

@@ -0,0 +1,33 @@
+{
+  "backend": "tokenizers",
+  "clean_up_tokenization_spaces": false,
+  "do_lower_case": false,
+  "eos_token": "<|endoftext|>",
+  "extra_special_tokens": [
+    "<|endoftext|>",
+    "[MASK]",
+    "[gMASK]",
+    "[sMASK]",
+    "<sop>",
+    "<eop>",
+    "<|system|>",
+    "<|user|>",
+    "<|assistant|>",
+    "<|observation|>",
+    "<|begin_of_image|>",
+    "<|end_of_image|>",
+    "<|begin_of_video|>",
+    "<|end_of_video|>",
+    "<|begin_of_audio|>",
+    "<|end_of_audio|>",
+    "<|begin_of_transcription|>",
+    "<|end_of_transcription|>"
+  ],
+  "is_local": true,
+  "model_max_length": 1048576,
+  "model_specific_special_tokens": {},
+  "pad_token": "<|endoftext|>",
+  "padding_side": "left",
+  "remove_space": false,
+  "tokenizer_class": "TokenizersBackend"
+}