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,4 @@
+{
+  "torch": "2.11.0+cu128",
+  "transformers": "5.15.0.dev0"
+}

README.md

@@ -0,0 +1,287 @@
+---
+library_name: transformers
+base_model:
+- thinkingmachines/Inkling
+---
+
+This tiny model is intended for debugging. It is randomly initialized using the configuration adapted from [thinkingmachines/Inkling](https://huggingface.co/thinkingmachines/Inkling).
+
+| File path | Size |
+|------|------|
+| model.safetensors | 7.3MB |
+
+
+### Example usage:
+
+```python
+import numpy as np
+import torch
+from PIL import Image
+from transformers import AutoModelForMultimodalLM, AutoProcessor
+
+model_id = "tiny-random/inkling"
+processor = AutoProcessor.from_pretrained(model_id)
+model = AutoModelForMultimodalLM.from_pretrained(
+    model_id,
+    dtype=torch.bfloat16,
+    device_map="cuda" if torch.cuda.is_available() else "cpu",
+)
+
+# Synthetic multimodal inputs — no network fetch.
+image = Image.fromarray(np.random.randint(0, 255, (80, 80, 3), dtype=np.uint8))
+sampling_rate = processor.feature_extractor.sampling_rate
+t = np.linspace(0, 0.2, int(sampling_rate * 0.2), endpoint=False)
+audio = (0.1 * np.sin(2 * np.pi * 440 * t)).astype(np.float32)
+
+messages = [
+    {
+        "role": "user",
+        "content": [
+            {"type": "image", "image": image},
+            {"type": "audio", "audio": audio},
+            {"type": "text", "text": "Describe the image and audio briefly."},
+        ],
+    },
+]
+inputs = processor.apply_chat_template(
+    messages,
+    add_generation_prompt=True,
+    tokenize=True,
+    return_dict=True,
+    return_tensors="pt",
+    reasoning_effort="none",
+    processor_kwargs={"sampling_rate": sampling_rate},
+).to(model.device, dtype=model.dtype)
+input_len = inputs["input_ids"].shape[-1]
+outputs = model.generate(**inputs, max_new_tokens=16)
+print(processor.decode(outputs[0], skip_special_tokens=False))
+```
+
+### Codes to create this repo:
+
+<details><summary>Click to expand</summary>
+
+```python
+import json
+from pathlib import Path
+
+import torch
+from huggingface_hub import file_exists, hf_hub_download
+from safetensors.torch import load_file, save_file
+from transformers import (
+    AutoConfig,
+    AutoProcessor,
+    GenerationConfig,
+    InklingForConditionalGeneration,
+    set_seed,
+)
+
+source_model_id = "thinkingmachines/Inkling"
+save_folder = "/tmp/tiny-random/inkling"
+
+processor = AutoProcessor.from_pretrained(source_model_id)
+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)
+
+# Only shrink size-critical dims. Keep kernel-sensitive knobs (d_rel, rel_extent,
+# sliding_window_size, num_experts_per_tok, n_shared_experts, ...) as upstream.
+hidden_size = 8
+num_mtp_layers = 1
+config_json['text_config'].update({
+    'hidden_size': hidden_size,
+    'num_hidden_layers': 2,
+    'num_attention_heads': 8,
+    'num_key_value_heads': 4,
+    'head_dim': 32,
+    'swa_num_attention_heads': 8,
+    'swa_num_key_value_heads': 4,
+    'swa_head_dim': 32,
+    'local_layer_ids': [0],  # keep 1 sliding + 1 global with 2 layers
+    'dense_mlp_idx': 1,  # 1 dense + 1 sparse
+    'dense_intermediate_size': 32,
+    'intermediate_size': 32,
+    'moe_intermediate_size': 32,
+})
+config_json['vision_config'].update({
+    'decoder_dmodel': hidden_size,
+    'n_layers': 2,
+})
+config_json['audio_config'].update({
+    'decoder_dmodel': hidden_size,
+})
+config_json['mtp_config'].update({
+    'num_nextn_predict_layers': num_mtp_layers,
+    'local_layer_ids': [0],
+})
+
+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)
+print(config)
+torch.set_default_dtype(torch.bfloat16)
+model = InklingForConditionalGeneration(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()
+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.2)
+        print(name, p.shape, f'{p.numel() / num_params:.2%}', f'{p.numel() * p.element_size() / 1024**2:.2f}MB')
+# Upstream MoE gate bias / global_scale are F32; sconv stays BF16 in the checkpoint.
+for name, module in model.named_modules():
+    if hasattr(module, "e_score_correction_bias"):
+        module.e_score_correction_bias = torch.nn.Parameter(
+            module.e_score_correction_bias.detach().float()
+        )
+    if name.endswith(".mlp.gate") and hasattr(module, "global_scale"):
+        module.global_scale = torch.nn.Parameter(module.global_scale.detach().float())
+model.save_pretrained(save_folder)
+
+# HF ignores `model.mtp.*` on main load; write them with original checkpoint naming.
+set_seed(42)
+path = Path(save_folder) / "model.safetensors"
+state = load_file(str(path))
+dense_prefix = "model.llm.layers.0."  # MTP blocks are dense
+dense_keys = {k: v for k, v in state.items() if k.startswith(dense_prefix)}
+for i in range(num_mtp_layers):
+    block_prefix = f"model.mtp.layers.{i}.transformer_block."
+    for src_key, tensor in dense_keys.items():
+        dst_key = block_prefix + src_key[len(dense_prefix):]
+        state[dst_key] = torch.empty_like(tensor)
+        torch.nn.init.normal_(state[dst_key], 0, 0.2)
+        print(dst_key, tuple(state[dst_key].shape))
+    for name, shape in (
+        (f"model.mtp.layers.{i}.embed_norm.weight", (hidden_size,)),
+        (f"model.mtp.layers.{i}.hidden_norm.weight", (hidden_size,)),
+        (f"model.mtp.layers.{i}.input_proj.weight", (hidden_size, hidden_size * 2)),
+    ):
+        state[name] = torch.empty(shape, dtype=torch.bfloat16)
+        torch.nn.init.normal_(state[name], 0, 0.2)
+        print(name, shape)
+# Keep checkpoint key dtypes aligned even if save_pretrained downcasts.
+for key, tensor in list(state.items()):
+    if key.endswith(".mlp.gate.bias") or key.endswith(".mlp.gate.global_scale"):
+        state[key] = tensor.float()
+save_file(state, str(path))
+```
+
+</details>
+
+### Printing the model:
+
+<details><summary>Click to expand</summary>
+
+```text
+InklingForConditionalGeneration(
+  (model): InklingModel(
+    (language_model): InklingTextModel(
+      (embed_tokens): Embedding(201024, 8)
+      (layers): ModuleList(
+        (0): InklingDecoderLayer(
+          (self_attn): InklingAttention(
+            (q_proj): Linear(in_features=8, out_features=256, bias=False)
+            (k_proj): Linear(in_features=8, out_features=128, bias=False)
+            (v_proj): Linear(in_features=8, out_features=128, bias=False)
+            (r_proj): Linear(in_features=8, out_features=128, bias=False)
+            (o_proj): Linear(in_features=256, out_features=8, bias=False)
+            (k_sconv): InklingShortConvolution(
+              (conv1d): Conv1d(128, 128, kernel_size=(4,), stride=(1,), padding=(3,), groups=128, bias=False)
+            )
+            (v_sconv): InklingShortConvolution(
+              (conv1d): Conv1d(128, 128, kernel_size=(4,), stride=(1,), padding=(3,), groups=128, bias=False)
+            )
+            (q_norm): InklingRMSNorm((32,), eps=1e-06)
+            (k_norm): InklingRMSNorm((32,), eps=1e-06)
+            (rel_logits_proj): InklingRelativeLogits()
+          )
+          (mlp): InklingMLP(
+            (gate_proj): Linear(in_features=8, out_features=32, bias=False)
+            (up_proj): Linear(in_features=8, out_features=32, bias=False)
+            (down_proj): Linear(in_features=32, out_features=8, bias=False)
+            (act_fn): SiLUActivation()
+          )
+          (input_layernorm): InklingRMSNorm((8,), eps=1e-06)
+          (post_attention_layernorm): InklingRMSNorm((8,), eps=1e-06)
+          (attn_sconv): InklingShortConvolution(
+            (conv1d): Conv1d(8, 8, kernel_size=(4,), stride=(1,), padding=(3,), groups=8, bias=False)
+          )
+          (mlp_sconv): InklingShortConvolution(
+            (conv1d): Conv1d(8, 8, kernel_size=(4,), stride=(1,), padding=(3,), groups=8, bias=False)
+          )
+        )
+        (1): InklingDecoderLayer(
+          (self_attn): InklingAttention(
+            (q_proj): Linear(in_features=8, out_features=256, bias=False)
+            (k_proj): Linear(in_features=8, out_features=128, bias=False)
+            (v_proj): Linear(in_features=8, out_features=128, bias=False)
+            (r_proj): Linear(in_features=8, out_features=128, bias=False)
+            (o_proj): Linear(in_features=256, out_features=8, bias=False)
+            (k_sconv): InklingShortConvolution(
+              (conv1d): Conv1d(128, 128, kernel_size=(4,), stride=(1,), padding=(3,), groups=128, bias=False)
+            )
+            (v_sconv): InklingShortConvolution(
+              (conv1d): Conv1d(128, 128, kernel_size=(4,), stride=(1,), padding=(3,), groups=128, bias=False)
+            )
+            (q_norm): InklingRMSNorm((32,), eps=1e-06)
+            (k_norm): InklingRMSNorm((32,), eps=1e-06)
+            (rel_logits_proj): InklingRelativeLogits()
+          )
+          (mlp): InklingMoE(
+            (gate): InklingTopkRouter()
+            (experts): InklingExperts(
+              (act_fn): SiLUActivation()
+            )
+            (shared_experts): InklingSharedExperts(
+              (act_fn): SiLUActivation()
+            )
+          )
+          (input_layernorm): InklingRMSNorm((8,), eps=1e-06)
+          (post_attention_layernorm): InklingRMSNorm((8,), eps=1e-06)
+          (attn_sconv): InklingShortConvolution(
+            (conv1d): Conv1d(8, 8, kernel_size=(4,), stride=(1,), padding=(3,), groups=8, bias=False)
+          )
+          (mlp_sconv): InklingShortConvolution(
+            (conv1d): Conv1d(8, 8, kernel_size=(4,), stride=(1,), padding=(3,), groups=8, bias=False)
+          )
+        )
+      )
+      (norm): InklingRMSNorm((8,), eps=1e-06)
+      (embed_norm): InklingRMSNorm((8,), eps=1e-06)
+    )
+    (audio_tower): InklingAudioModel(
+      (embed_audio_tokens): InklingAudioModelEmbeddings(
+        (embed_audio_tokens): Embedding(1280, 8)
+      )
+      (norm): InklingRMSNorm((8,), eps=1e-06)
+    )
+    (vision_tower): InklingVisionModel(
+      (encoder_layers): ModuleList(
+        (0): InklingVisionEncoderLayer(
+          (projection): Linear(in_features=300, out_features=320, bias=False)
+          (layer_norm): InklingRMSNorm((320,), eps=1e-06)
+        )
+        (1): InklingVisionEncoderLayer(
+          (projection): Linear(in_features=10240, out_features=8, bias=False)
+        )
+      )
+      (final_norm): InklingRMSNorm((8,), eps=1e-06)
+    )
+  )
+  (lm_head): Linear(in_features=8, out_features=201024, bias=False)
+)
+```
+
+</details>
+
+### Test environment:
+
+- torch: 2.11.0+cu128
+- transformers: 5.15.0.dev0

chat_template.jinja

@@ -0,0 +1,129 @@
+{%- set effort_map = {"none": 0.0, "minimal": 0.1, "low": 0.2, "medium": 0.7, "high": 0.9, "max": 0.99} -%}
+{%- set role_token = {"user": "<|message_user|>", "assistant": "<|message_model|>", "system": "<|message_system|>", "tool": "<|message_tool|>"} -%}
+
+{%- macro emit_thinking_effort() -%}
+    {%- set eff = reasoning_effort if reasoning_effort is defined and reasoning_effort is not none else 0.9 -%}
+    {%- if eff is string -%}
+        {%- set key = eff | trim -%}
+        {%- if key not in effort_map -%}
+            {{- raise_exception("Unknown reasoning_effort: " ~ eff) -}}
+        {%- endif -%}
+        {%- set num = effort_map[key] -%}
+    {%- else -%}
+        {%- set num = eff | float -%}
+    {%- endif -%}
+    {%- if num < 0.0 or num > 0.99 -%}
+        {{- raise_exception("reasoning_effort must be in [0.0, 0.99]") -}}
+    {%- endif -%}
+    {{- "<|message_system|><|content_text|>Thinking effort level: " -}}
+    {%- if num == 0.0 -%}0{%- else -%}{{ num }}{%- endif -%}
+    {{- "<|end_message|>" -}}
+{%- endmacro -%}
+
+{%- if tools -%}
+    {%- set tool_state = namespace(specs=[]) -%}
+    {%- for tool in tools -%}
+        {%- set fn = tool.function if tool.function is defined else tool -%}
+        {%- set spec = {
+            "description": (fn.description if fn.description is defined and fn.description else ""),
+            "name": fn.name,
+            "parameters": (fn.parameters if fn.parameters is defined and fn.parameters else {}),
+            "type": (tool.type if tool.type is defined and tool.type else "function"),
+        } -%}
+        {%- set tool_state.specs = tool_state.specs + [spec] -%}
+    {%- endfor -%}
+    {{- "<|message_system|>tool_declare<|content_xml|>" -}}
+    {{- tool_state.specs | tojson(sort_keys=true, separators=(",", ":")) -}}
+    {{- "<|end_message|>" -}}
+{%- endif -%}
+
+{%- set state = namespace(effort_emitted=false) -%}
+{%- for message in messages -%}
+    {%- if message.role not in role_token -%}
+        {{- raise_exception("Unknown message role: " ~ message.role) -}}
+    {%- endif -%}
+    {%- if not state.effort_emitted and message.role != "system" -%}
+        {{- emit_thinking_effort() -}}
+        {%- set state.effort_emitted = true -%}
+    {%- endif -%}
+
+    {%- set rtok = role_token[message.role] -%}
+
+    {%- if message.role == "tool" -%}
+        {%- set tool_name_state = namespace(name="") -%}
+        {%- if message.name is defined and message.name -%}
+            {%- set tool_name_state.name = message.name -%}
+        {%- elif message.tool_call_id is defined and message.tool_call_id -%}
+            {%- for prev in messages -%}
+                {%- if prev.role == "assistant" and prev.tool_calls -%}
+                    {%- for tc in prev.tool_calls -%}
+                        {%- if tc.id is defined and tc.id == message.tool_call_id and tc.function.name is defined -%}
+                            {%- set tool_name_state.name = tc.function.name -%}
+                        {%- endif -%}
+                    {%- endfor -%}
+                {%- endif -%}
+            {%- endfor -%}
+        {%- endif -%}
+        {{- rtok -}}
+        {%- if tool_name_state.name -%}{{- tool_name_state.name -}}{%- endif -%}
+        {{- "<|content_text|>" -}}
+        {%- if message.content is string -%}{{- message.content -}}{%- endif -%}
+        {{- "<|end_message|>" -}}
+
+    {%- else -%}
+        {%- if message.role == "assistant" and message.reasoning_content is defined and message.reasoning_content -%}
+            {{- "<|message_model|><|content_thinking|>" ~ message.reasoning_content ~ "<|end_message|>" -}}
+        {%- endif -%}
+
+        {%- if message.content is string -%}
+            {{- rtok ~ "<|content_text|>" ~ message.content ~ "<|end_message|>" -}}
+        {%- elif message.content -%}
+            {%- for part in message.content -%}
+                {%- if part is string -%}
+                    {{- rtok ~ "<|content_text|>" ~ part ~ "<|end_message|>" -}}
+                {%- elif part.type is not defined or part.type in ("text", "input_text") -%}
+                    {%- set text_part = (part.text if part.text is defined and part.text is string else "") -%}
+                    {{- rtok ~ "<|content_text|>" ~ text_part ~ "<|end_message|>" -}}
+                {%- elif part.type in ("image", "input_image", "image_url") -%}
+                    {{- rtok ~ "<|content_image|><|unused_200054|><|end_message|>" -}}
+                {%- elif part.type in ("audio", "input_audio", "audio_url") -%}
+                    {{- rtok ~ "<|content_audio_input|><|unused_200053|><|audio_end|><|end_message|>" -}}
+                {%- else -%}
+                    {{- raise_exception("Unsupported content part type: " ~ part.type) -}}
+                {%- endif -%}
+            {%- endfor -%}
+        {%- endif -%}
+
+        {%- if message.role == "assistant" and message.tool_calls -%}
+            {%- for tc in message.tool_calls -%}
+                {%- set fn = tc.function -%}
+                {%- if fn.name is not defined or fn.name is not string -%}
+                    {{- raise_exception("tool call function name must be a string") -}}
+                {%- endif -%}
+                {%- set args = fn.arguments if fn.arguments is defined and fn.arguments else {} -%}
+                {%- if args is string -%}
+                    {{- raise_exception("tool call arguments must be a parsed object, not a JSON string; canonicalize upstream") -}}
+                {%- endif -%}
+                {%- if args is not mapping -%}
+                    {{- raise_exception("tool call arguments must be an object") -}}
+                {%- endif -%}
+                {{- "<|message_model|>" ~ fn.name ~ "<|content_invoke_tool_json|>" -}}
+                {{- '{"name":' ~ (fn.name | tojson(sort_keys=true, separators=(",", ":"))) ~ ',"args":' -}}
+                {{- (args | tojson(sort_keys=true, separators=(",", ":"))) -}}
+                {{- "}<|end_message|>" -}}
+            {%- endfor -%}
+        {%- endif -%}
+
+        {%- if message.role == "assistant" -%}
+            {{- "<|content_model_end_sampling|>" -}}
+        {%- endif -%}
+    {%- endif -%}
+{%- endfor -%}
+
+{%- if not state.effort_emitted -%}
+    {{- emit_thinking_effort() -}}
+{%- endif -%}
+
+{%- if add_generation_prompt -%}
+    {{- "<|message_model|>" -}}
+{%- endif -%}

config.json

@@ -0,0 +1,114 @@
+{
+  "architectures": [
+    "InklingForConditionalGeneration"
+  ],
+  "audio_bos_token_id": 200020,
+  "audio_config": {
+    "audio_mode": "dmel",
+    "bias": false,
+    "decoder_dmodel": 8,
+    "dmel_max_value": 2.0,
+    "dmel_min_value": -7.0,
+    "initializer_range": 0.02,
+    "mel_vocab_size": 16,
+    "model_type": "inkling_audio",
+    "n_mel_bins": 80,
+    "rms_norm_eps": 1e-06,
+    "text_hidden_size": 8,
+    "use_audio_norm": true
+  },
+  "audio_token_id": 200053,
+  "dtype": "bfloat16",
+  "eos_token_id": 200006,
+  "image_bos_token_id": 200005,
+  "image_token_id": 200054,
+  "model_type": "inkling_mm_model",
+  "mtp_config": {
+    "chain_hidden_post_norm": false,
+    "local_layer_ids": [
+      0
+    ],
+    "num_nextn_predict_layers": 1
+  },
+  "text_config": {
+    "attention_dropout": 0.0,
+    "bos_token_id": 1,
+    "chain_hidden_post_norm": false,
+    "conv_kernel_size": 4,
+    "d_rel": 16,
+    "dtype": "bfloat16",
+    "eos_token_id": 2,
+    "final_logit_softcapping": null,
+    "gate_activation": "sigmoid",
+    "head_dim": 32,
+    "hidden_act": "silu",
+    "hidden_size": 8,
+    "initializer_range": 0.02,
+    "intermediate_size": 32,
+    "layer_types": [
+      "hybrid_sliding",
+      "hybrid"
+    ],
+    "local_layer_ids": [
+      0
+    ],
+    "log_scaling_alpha": 0.1,
+    "log_scaling_n_floor": 128000,
+    "logits_mup_width_multiplier": 24.0,
+    "max_position_embeddings": 1048576,
+    "mlp_layer_types": [
+      "dense",
+      "sparse"
+    ],
+    "model_type": "inkling_text",
+    "moe_intermediate_size": 32,
+    "mtp_hidden_states_first": true,
+    "mtp_local_layer_ids": [
+      0
+    ],
+    "n_routed_experts": 256,
+    "n_shared_experts": 2,
+    "norm_after_topk": true,
+    "num_attention_heads": 8,
+    "num_experts_per_tok": 6,
+    "num_hidden_layers": 2,
+    "num_key_value_heads": 4,
+    "num_mtp_layers": 1,
+    "number_of_conv_states": 4,
+    "o_bias": false,
+    "pad_token_id": null,
+    "q_bias": false,
+    "rel_extent": 1024,
+    "rms_norm_eps": 1e-06,
+    "rms_norm_eps_moe_gate": 1e-06,
+    "route_scale": 8.0,
+    "shared_expert_sink": true,
+    "sliding_window_size": 512,
+    "swa_head_dim": 32,
+    "swa_num_attention_heads": 8,
+    "swa_num_key_value_heads": 4,
+    "unpadded_vocab_size": 200058,
+    "use_embed_norm": true,
+    "use_gate_bias": true,
+    "use_global_scale": true,
+    "use_sconv": true,
+    "vocab_size": 201024
+  },
+  "transformers_version": "5.15.0.dev0",
+  "vision_config": {
+    "decoder_dmodel": 8,
+    "hidden_size": 1024,
+    "initializer_range": 0.02,
+    "model_type": "inkling_vision",
+    "n_channels": 3,
+    "n_layers": 2,
+    "num_attention_heads": 16,
+    "num_channels": 3,
+    "patch_size": 40,
+    "rms_norm_eps": 1e-06,
+    "temporal_patch_size": 2,
+    "text_hidden_size": 8,
+    "use_vision_norm": true,
+    "vision_encoder_type": "hmlp"
+  }
+}

generation_config.json

@@ -0,0 +1,8 @@
+{
+  "_from_model_config": true,
+  "bos_token_id": 1,
+  "eos_token_id": 200006,
+  "output_attentions": false,
+  "output_hidden_states": false,
+  "transformers_version": "5.15.0.dev0"
+}

model.safetensors

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

processor_config.json

@@ -0,0 +1,47 @@
+{
+  "audio_bos_token": "<|content_audio_input|>",
+  "audio_token": "<|unused_200053|>",
+  "dmel_max_value": 2.0,
+  "dmel_min_value": -7.0,
+  "feature_extractor": {
+    "audio_token_duration_s": 0.05,
+    "feature_extractor_type": "InklingFeatureExtractor",
+    "feature_size": 80,
+    "hop_length": 800,
+    "n_fft": 1600,
+    "padding_side": "right",
+    "padding_value": 0.0,
+    "return_attention_mask": true,
+    "sampling_rate": 16000,
+    "window_size": 1600,
+    "window_size_multiplier": 2.0
+  },
+  "image_bos_token": "<|content_image|>",
+  "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": "InklingImageProcessor",
+    "image_std": [
+      0.26862954,
+      0.26130258,
+      0.27577711
+    ],
+    "resample": 3,
+    "rescale_factor": 0.00392156862745098,
+    "rescale_image_max_upscaled_long_edge": 2048,
+    "size": {
+      "height": 40,
+      "width": 40
+    }
+  },
+  "image_token": "<|unused_200054|>",
+  "num_dmel_bins": 16,
+  "processor_class": "InklingProcessor"
+}

tokenizer.json

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

tokenizer_config.json

@@ -0,0 +1,48 @@
+{
+  "audio": "<|audio|>",
+  "audio_end": "<|audio_end|>",
+  "backend": "tokenizers",
+  "begin_of_text": "<|begin_of_text|>",
+  "clean_up_tokenization_spaces": false,
+  "content_audio_input": "<|content_audio_input|>",
+  "content_image": "<|content_image|>",
+  "content_invoke_tool_json": "<|content_invoke_tool_json|>",
+  "content_invoke_tool_text": "<|content_invoke_tool_text|>",
+  "content_model_end_sampling": "<|content_model_end_sampling|>",
+  "content_text": "<|content_text|>",
+  "content_thinking": "<|content_thinking|>",
+  "content_tool_error": "<|content_tool_error|>",
+  "content_xml": "<|content_xml|>",
+  "end_message": "<|end_message|>",
+  "endoftext": "<|endoftext|>",
+  "fix_mistral_regex": false,
+  "is_local": false,
+  "local_files_only": false,
+  "message_model": "<|message_model|>",
+  "message_system": "<|message_system|>",
+  "message_tool": "<|message_tool|>",
+  "message_user": "<|message_user|>",
+  "model_max_length": 1000000000000000019884624838656,
+  "model_specific_special_tokens": {
+    "audio": "<|audio|>",
+    "audio_end": "<|audio_end|>",
+    "begin_of_text": "<|begin_of_text|>",
+    "content_audio_input": "<|content_audio_input|>",
+    "content_image": "<|content_image|>",
+    "content_invoke_tool_json": "<|content_invoke_tool_json|>",
+    "content_invoke_tool_text": "<|content_invoke_tool_text|>",
+    "content_model_end_sampling": "<|content_model_end_sampling|>",
+    "content_text": "<|content_text|>",
+    "content_thinking": "<|content_thinking|>",
+    "content_tool_error": "<|content_tool_error|>",
+    "content_xml": "<|content_xml|>",
+    "end_message": "<|end_message|>",
+    "endoftext": "<|endoftext|>",
+    "message_model": "<|message_model|>",
+    "message_system": "<|message_system|>",
+    "message_tool": "<|message_tool|>",
+    "message_user": "<|message_user|>"
+  },
+  "processor_class": "InklingProcessor",
+  "tokenizer_class": "TokenizersBackend"
+}