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

README.md

@@ -0,0 +1,218 @@
+---
+library_name: transformers
+base_model:
+- zai-org/GLM-4.6V
+---
+
+This tiny model is intended for debugging. It is randomly initialized using the configuration adapted from [zai-org/GLM-4.6V](https://huggingface.co/zai-org/GLM-4.6V).
+
+### Example usage:
+
+```python
+import torch
+from transformers import AutoProcessor, Glm4vMoeForConditionalGeneration
+
+model_id = "tiny-random/glm-4.6v"
+messages = [
+    {
+        "role": "user",
+        "content": [
+            {
+                "type": "image",
+                "url": "https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/p-blog/candy.JPG"
+            },
+            {
+                "type": "text",
+                "text": "describe this image"
+            }
+        ],
+    }
+]
+processor = AutoProcessor.from_pretrained(model_id)
+model = Glm4vMoeForConditionalGeneration.from_pretrained(
+    model_id,
+    torch_dtype=torch.bfloat16,
+    device_map="cuda",
+)
+inputs = processor.apply_chat_template(
+    messages,
+    tokenize=True,
+    add_generation_prompt=True,
+    return_dict=True,
+    return_tensors="pt"
+).to(model.device)
+inputs.pop("token_type_ids", None)
+generated_ids = model.generate(**inputs, max_new_tokens=16)
+output_text = processor.decode(
+    generated_ids[0][inputs["input_ids"].shape[1]:], skip_special_tokens=False)
+print(output_text)
+```
+
+### Codes to create this repo:
+
+```python
+import json
+from pathlib import Path
+
+import accelerate
+import torch
+from huggingface_hub import file_exists, hf_hub_download
+from transformers import (
+    AutoConfig,
+    AutoModelForCausalLM,
+    AutoProcessor,
+    GenerationConfig,
+    Glm4vForConditionalGeneration,
+    Glm4vMoeForConditionalGeneration,
+    set_seed,
+)
+from transformers.models.glm4v_moe.modeling_glm4v_moe import Glm4vMoeTextTopkRouter
+
+source_model_id = "zai-org/GLM-4.6V"
+save_folder = "/tmp/tiny-random/glm-4.6v"
+processor = AutoProcessor.from_pretrained(
+    source_model_id, trust_remote_code=True)
+processor.save_pretrained(save_folder)
+
+with open(hf_hub_download(source_model_id, filename='config.json', repo_type='model'), 'r', encoding='utf-8') as f:
+    config_json = json.load(f)
+config_json['text_config'].update({
+    "hidden_size": 8,
+    "head_dim": 32,
+    "intermediate_size": 64,
+    "first_k_dense_replace": 1,
+    "moe_intermediate_size": 64,
+    "num_attention_heads": 8,
+    "num_key_value_heads": 4,
+    "num_hidden_layers": 2,  # one dense, one moe
+    "tie_word_embeddings": True,
+})
+config_json['text_config']['rope_parameters']['mrope_section'] = [2, 2, 4]
+config_json['vision_config']['hidden_size'] = 64
+config_json['vision_config']['depth'] = 2
+config_json['vision_config']['num_heads'] = 2
+config_json['vision_config']['intermediate_size'] = 64
+config_json['vision_config']['out_hidden_size'] = config_json['text_config']['hidden_size']
+
+with open(f"{save_folder}/config.json", "w", encoding='utf-8') as f:
+    json.dump(config_json, f, indent=2)
+
+config = AutoConfig.from_pretrained(
+    save_folder,
+    trust_remote_code=True,
+)
+print(config)
+torch.set_default_dtype(torch.bfloat16)
+model = Glm4vMoeForConditionalGeneration(config)
+torch.set_default_dtype(torch.float32)
+if file_exists(filename="generation_config.json", repo_id=source_model_id, repo_type='model'):
+    model.generation_config = GenerationConfig.from_pretrained(
+        source_model_id, trust_remote_code=True,
+    )
+set_seed(42)
+model = model.cpu()  # cpu is more stable for random initialization across machines
+num_params = sum(p.numel() for p in model.parameters())
+with torch.no_grad():
+    for name, p in sorted(model.named_parameters()):
+        torch.nn.init.normal_(p, 0, 0.1)
+        print(name, p.shape, p.dtype, p.device,
+              f'{p.numel() / num_params * 100: .2f}%')
+for _, m in sorted(model.named_modules()):
+    if isinstance(m, Glm4vMoeTextTopkRouter):
+        assert 'e_score_correction_bias' in m.state_dict()
+        torch.nn.init.normal_(m.e_score_correction_bias, 0, 1)
+model.save_pretrained(save_folder)
+print(model)
+```
+
+### Printing the model:
+
+```text
+Glm4vMoeForConditionalGeneration(
+  (model): Glm4vMoeModel(
+    (visual): Glm4vMoeVisionModel(
+      (embeddings): Glm4vMoeVisionEmbeddings(
+        (position_embedding): Embedding(576, 64)
+      )
+      (patch_embed): Glm4vMoeVisionPatchEmbed(
+        (proj): Conv3d(3, 64, kernel_size=(2, 14, 14), stride=(2, 14, 14))
+      )
+      (rotary_pos_emb): Glm4vMoeVisionRotaryEmbedding()
+      (blocks): ModuleList(
+        (0-1): 2 x Glm4vMoeVisionBlock(
+          (norm1): Glm4vMoeRMSNorm((64,), eps=1e-05)
+          (norm2): Glm4vMoeRMSNorm((64,), eps=1e-05)
+          (attn): Glm4vMoeVisionAttention(
+            (qkv): Linear(in_features=64, out_features=192, bias=False)
+            (proj): Linear(in_features=64, out_features=64, bias=False)
+          )
+          (mlp): Glm4vMoeisionMlp(
+            (gate_proj): Linear(in_features=64, out_features=8, bias=False)
+            (up_proj): Linear(in_features=64, out_features=8, bias=False)
+            (down_proj): Linear(in_features=8, out_features=64, bias=False)
+            (act_fn): SiLUActivation()
+          )
+        )
+      )
+      (merger): Glm4vMoeVisionPatchMerger(
+        (proj): Linear(in_features=8, out_features=8, bias=False)
+        (post_projection_norm): LayerNorm((8,), eps=1e-05, elementwise_affine=True)
+        (gate_proj): Linear(in_features=8, out_features=64, bias=False)
+        (up_proj): Linear(in_features=8, out_features=64, bias=False)
+        (down_proj): Linear(in_features=64, out_features=8, bias=False)
+        (act1): GELU(approximate='none')
+        (act_fn): SiLUActivation()
+      )
+      (post_conv_layernorm): Glm4vMoeRMSNorm((64,), eps=1e-05)
+      (downsample): Conv2d(64, 8, kernel_size=(2, 2), stride=(2, 2))
+      (post_layernorm): Glm4vMoeRMSNorm((64,), eps=1e-05)
+    )
+    (language_model): Glm4vMoeTextModel(
+      (embed_tokens): Embedding(151552, 8, padding_idx=151329)
+      (layers): ModuleList(
+        (0): Glm4vMoeTextDecoderLayer(
+          (self_attn): Glm4vMoeTextAttention(
+            (q_proj): Linear(in_features=8, out_features=256, bias=True)
+            (k_proj): Linear(in_features=8, out_features=128, bias=True)
+            (v_proj): Linear(in_features=8, out_features=128, bias=True)
+            (o_proj): Linear(in_features=256, out_features=8, bias=False)
+          )
+          (mlp): Glm4vMoeTextMLP(
+            (gate_proj): Linear(in_features=8, out_features=64, bias=False)
+            (up_proj): Linear(in_features=8, out_features=64, bias=False)
+            (down_proj): Linear(in_features=64, out_features=8, bias=False)
+            (act_fn): SiLUActivation()
+          )
+          (input_layernorm): Glm4vMoeTextRMSNorm((8,), eps=1e-05)
+          (post_attention_layernorm): Glm4vMoeTextRMSNorm((8,), eps=1e-05)
+        )
+        (1): Glm4vMoeTextDecoderLayer(
+          (self_attn): Glm4vMoeTextAttention(
+            (q_proj): Linear(in_features=8, out_features=256, bias=True)
+            (k_proj): Linear(in_features=8, out_features=128, bias=True)
+            (v_proj): Linear(in_features=8, out_features=128, bias=True)
+            (o_proj): Linear(in_features=256, out_features=8, bias=False)
+          )
+          (mlp): Glm4vMoeTextMoE(
+            (experts): Glm4vMoeTextNaiveMoe(
+              (act_fn): SiLUActivation()
+            )
+            (gate): Glm4vMoeTextTopkRouter()
+            (shared_experts): Glm4vMoeTextMLP(
+              (gate_proj): Linear(in_features=8, out_features=64, bias=False)
+              (up_proj): Linear(in_features=8, out_features=64, bias=False)
+              (down_proj): Linear(in_features=64, out_features=8, bias=False)
+              (act_fn): SiLUActivation()
+            )
+          )
+          (input_layernorm): Glm4vMoeTextRMSNorm((8,), eps=1e-05)
+          (post_attention_layernorm): Glm4vMoeTextRMSNorm((8,), eps=1e-05)
+        )
+      )
+      (norm): Glm4vMoeRMSNorm((8,), eps=1e-05)
+      (rotary_emb): Glm4vMoeTextRotaryEmbedding()
+    )
+  )
+  (lm_head): Linear(in_features=8, out_features=151552, bias=False)
+)
+```

chat_template.jinja

@@ -0,0 +1,141 @@
+[gMASK]<sop>
+{%- if tools -%}
+<|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 %}
+{{ tool | tojson(ensure_ascii=False) }}
+{% 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 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 mapping and (item.type == 'image' or 'image' in item) -%}
+                <|begin_of_image|><|image|><|end_of_image|>
+            {%- elif item is mapping and (item.type == 'video' or 'video' in item) -%}
+                <|begin_of_video|><|video|><|end_of_video|>
+            {%- elif item is string -%}
+                {{- item }}
+            {%- endif -%}
+        {%- endfor -%}
+    {%- else -%}
+        {{- content }}
+    {%- 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|>
+{% if m.content is string %}
+{{ m.content }}
+{%- else %}
+{%- for item in m.content %}
+{% if item.type == 'video' or 'video' in item %}
+<|begin_of_video|><|video|><|end_of_video|>{% elif item.type == 'image' or 'image' in item %}
+<|begin_of_image|><|image|><|end_of_image|>{% elif item.type == 'text' %}
+{{ item.text }}
+{%- endif %}
+{%- endfor %}
+{%- endif %}
+{{- '/nothink' if (enable_thinking is defined and not enable_thinking and not visible_text(m.content).endswith("/nothink")) else '' -}}
+{%- elif m.role == 'assistant' -%}
+<|assistant|>
+{%- set reasoning_content = '' %}
+{%- set content = visible_text(m.content) %}
+{%- if m.reasoning_content is string %}
+    {%- set reasoning_content = m.reasoning_content %}
+{%- else %}
+    {%- if '</think>' in content %}
+        {%- set reasoning_content = content.split('</think>')[0].rstrip('\n').split('<think>')[-1].lstrip('\n') %}
+        {%- set content = content.split('</think>')[-1].lstrip('\n') %}
+    {%- endif %}
+{%- endif %}
+{%- if loop.index0 > ns.last_user_index and reasoning_content -%}
+{{ '\n<think>' + reasoning_content.strip() +  '</think>'}}
+{%- else -%}
+{{ '\n<think></think>' }}
+{%- endif -%}
+{%- if content.strip() -%}
+{{ '\n' + content.strip() }}
+{%- endif -%}
+{% if m.tool_calls %}
+{% for tc in m.tool_calls %}
+{%- if tc.function %}
+    {%- set tc = tc.function %}
+{%- endif %}
+{{ '\n<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 m.content is string -%}
+{%- if loop.first or (messages[loop.index0 - 1].role != "tool") %}
+    {{- '<|observation|>' }}
+{%- endif %}
+{{- '\n<tool_response>\n' }}
+{{- m.content }}
+{{- '\n</tool_response>' }}
+{% elif m.content is iterable and m.content is not mapping %}
+{%- if loop.first or (messages[loop.index0 - 1].role != "tool") %}
+{{- '<|observation|>' }}
+{%- endif %}
+{{- '\n<tool_response>\n' }}
+{%- for tr in m.content -%}
+  {%- if tr is mapping and tr.type is defined -%}
+    {%- set t = tr.type | lower -%}
+    {%- if t == 'text' and tr.text is defined -%}
+{{ tr.text }}
+    {%- elif t in ['image', 'image_url'] -%}
+<|begin_of_image|><|image|><|end_of_image|>
+    {%- elif t in ['video', 'video_url'] -%}
+<|begin_of_video|><|video|><|end_of_video|>
+    {%- else -%}
+{{ tr | tojson(ensure_ascii=False) }}
+    {%- endif -%}
+  {%- else -%}
+{{ tr.output if tr.output is defined else tr }}
+  {%- endif -%}
+{%- endfor -%}
+{{- '\n</tool_response>' }}
+{%- else -%}
+<|observation|>{% for tr in m.content %}
+
+<tool_response>
+{{ tr.output if tr.output is defined else tr }}
+</tool_response>{% endfor -%}
+{% endif -%}
+{# ====== 逻辑结束 ====== #}
+{%- elif m.role == 'system' -%}
+<|system|>
+{{ visible_text(m.content) }}
+{%- endif -%}
+{%- endfor -%}
+{%- if add_generation_prompt -%}
+<|assistant|>
+{{'<think></think>\n' if (enable_thinking is defined and not enable_thinking) else ''}}
+{%- endif -%}

config.json

@@ -0,0 +1,83 @@
+{
+  "architectures": [
+    "Glm4vMoeForConditionalGeneration"
+  ],
+  "dtype": "bfloat16",
+  "image_end_token_id": 151340,
+  "image_start_token_id": 151339,
+  "image_token_id": 151363,
+  "model_type": "glm4v_moe",
+  "text_config": {
+    "attention_bias": true,
+    "attention_dropout": 0.0,
+    "dtype": "bfloat16",
+    "eos_token_id": [
+      151329,
+      151336,
+      151338
+    ],
+    "first_k_dense_replace": 1,
+    "head_dim": 32,
+    "hidden_act": "silu",
+    "hidden_size": 8,
+    "initializer_range": 0.02,
+    "intermediate_size": 64,
+    "max_position_embeddings": 131072,
+    "model_type": "glm4v_moe_text",
+    "moe_intermediate_size": 64,
+    "n_group": 1,
+    "n_routed_experts": 128,
+    "n_shared_experts": 1,
+    "norm_topk_prob": true,
+    "num_attention_heads": 8,
+    "num_experts_per_tok": 8,
+    "num_hidden_layers": 2,
+    "num_key_value_heads": 4,
+    "num_nextn_predict_layers": 0,
+    "pad_token_id": 151329,
+    "partial_rotary_factor": 0.5,
+    "qk_layernorm": false,
+    "rms_norm_eps": 1e-05,
+    "rope_parameters": {
+      "mrope_section": [
+        2,
+        2,
+        4
+      ],
+      "partial_rotary_factor": 0.5,
+      "rope_theta": 500000,
+      "rope_type": "default"
+    },
+    "routed_scaling_factor": 1.0,
+    "router_aux_loss_coef": 0.0001,
+    "tie_word_embeddings": true,
+    "topk_group": 1,
+    "use_cache": true,
+    "use_qk_norm": false,
+    "vocab_size": 151552
+  },
+  "tie_word_embeddings": false,
+  "transformers_version": "5.0.0.dev0",
+  "video_end_token_id": 151342,
+  "video_start_token_id": 151341,
+  "video_token_id": 151364,
+  "vision_config": {
+    "attention_bias": false,
+    "attention_dropout": 0.0,
+    "depth": 2,
+    "hidden_act": "silu",
+    "hidden_dropout_prob": 0.0,
+    "hidden_size": 64,
+    "image_size": 336,
+    "in_channels": 3,
+    "initializer_range": 0.02,
+    "intermediate_size": 64,
+    "model_type": "glm4v_moe_vision",
+    "num_heads": 2,
+    "out_hidden_size": 8,
+    "patch_size": 14,
+    "rms_norm_eps": 1e-05,
+    "spatial_merge_size": 2,
+    "temporal_patch_size": 2
+  }
+}

generation_config.json

@@ -0,0 +1,14 @@
+{
+  "_from_model_config": true,
+  "do_sample": true,
+  "eos_token_id": [
+    151329,
+    151336,
+    151338
+  ],
+  "pad_token_id": 151329,
+  "temperature": 0.8,
+  "top_k": 2,
+  "top_p": 0.6,
+  "transformers_version": "5.0.0.dev0"
+}

model.safetensors

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

processor_config.json

@@ -0,0 +1,67 @@
+{
+  "image_processor": {
+    "do_convert_rgb": true,
+    "do_normalize": true,
+    "do_rescale": true,
+    "do_resize": true,
+    "image_mean": [
+      0.48145466,
+      0.4578275,
+      0.40821073
+    ],
+    "image_processor_type": "Glm46VImageProcessor",
+    "image_std": [
+      0.26862954,
+      0.26130258,
+      0.27577711
+    ],
+    "merge_size": 2,
+    "patch_size": 14,
+    "processor_class": "Glm46VProcessor",
+    "resample": 3,
+    "rescale_factor": 0.00392156862745098,
+    "size": {
+      "longest_edge": 9633792,
+      "shortest_edge": 12544
+    },
+    "temporal_patch_size": 2
+  },
+  "processor_class": "Glm46VProcessor",
+  "video_processor": {
+    "data_format": "channels_first",
+    "default_to_square": true,
+    "do_convert_rgb": true,
+    "do_normalize": true,
+    "do_rescale": true,
+    "do_resize": true,
+    "do_sample_frames": true,
+    "fps": 2,
+    "image_mean": [
+      0.48145466,
+      0.4578275,
+      0.40821073
+    ],
+    "image_std": [
+      0.26862954,
+      0.26130258,
+      0.27577711
+    ],
+    "max_duration": 300,
+    "max_image_size": {
+      "longest_edge": 47040000
+    },
+    "merge_size": 2,
+    "num_frames": 16,
+    "patch_size": 14,
+    "processor_class": "Glm46VProcessor",
+    "resample": 3,
+    "rescale_factor": 0.00392156862745098,
+    "return_metadata": false,
+    "size": {
+      "longest_edge": 47040000,
+      "shortest_edge": 12544
+    },
+    "temporal_patch_size": 2,
+    "video_processor_type": "Glm46VVideoProcessor"
+  }
+}

tokenizer.json

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

tokenizer_config.json

@@ -0,0 +1,66 @@
+{
+  "additional_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|>",
+    "<|image|>",
+    "<|video|>",
+    "<|begin_of_transcription|>",
+    "<|end_of_transcription|>",
+    "<|code_prefix|>",
+    "<|code_middle|>",
+    "<|code_suffix|>",
+    "/nothink"
+  ],
+  "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|>",
+    "<|image|>",
+    "<|video|>",
+    "<|begin_of_transcription|>",
+    "<|end_of_transcription|>",
+    "<|code_prefix|>",
+    "<|code_middle|>",
+    "<|code_suffix|>",
+    "/nothink"
+  ],
+  "is_local": false,
+  "model_max_length": 128000,
+  "model_specific_special_tokens": {},
+  "pad_token": "<|endoftext|>",
+  "padding_side": "left",
+  "processor_class": "Glm46VProcessor",
+  "remove_space": false,
+  "tokenizer_class": "TokenizersBackend"
+}