Adding the quantized model files

- including the python script for model quantization and evaluation

.gitattributes

@@ -33,3 +33,6 @@ 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
+model.safetensors filter=lfs diff=lfs merge=lfs -text
+tokenizer.json filter=lfs diff=lfs merge=lfs -text
+vocab.json filter=lfs diff=lfs merge=lfs -text

added_tokens.json

@@ -0,0 +1,28 @@
+{
+  "</think>": 151668,
+  "</tool_call>": 151658,
+  "</tool_response>": 151666,
+  "<think>": 151667,
+  "<tool_call>": 151657,
+  "<tool_response>": 151665,
+  "<|box_end|>": 151649,
+  "<|box_start|>": 151648,
+  "<|endoftext|>": 151643,
+  "<|file_sep|>": 151664,
+  "<|fim_middle|>": 151660,
+  "<|fim_pad|>": 151662,
+  "<|fim_prefix|>": 151659,
+  "<|fim_suffix|>": 151661,
+  "<|im_end|>": 151645,
+  "<|im_start|>": 151644,
+  "<|image_pad|>": 151655,
+  "<|object_ref_end|>": 151647,
+  "<|object_ref_start|>": 151646,
+  "<|quad_end|>": 151651,
+  "<|quad_start|>": 151650,
+  "<|repo_name|>": 151663,
+  "<|video_pad|>": 151656,
+  "<|vision_end|>": 151653,
+  "<|vision_pad|>": 151654,
+  "<|vision_start|>": 151652
+}

chat_template.jinja

@@ -0,0 +1,120 @@
+{%- if tools %}
+    {{- '<|im_start|>system\n' }}
+    {%- if messages[0].role == 'system' %}
+        {%- if messages[0].content is string %}
+            {{- messages[0].content }}
+        {%- else %}
+            {%- for content in messages[0].content %}
+                {%- if 'text' in content %}
+                    {{- content.text }}
+                {%- endif %}
+            {%- endfor %}
+        {%- endif %}
+        {{- '\n\n' }}
+    {%- endif %}
+    {{- "# Tools\n\nYou may call one or more functions to assist with the user query.\n\nYou are provided with function signatures within <tools></tools> XML tags:\n<tools>" }}
+    {%- for tool in tools %}
+        {{- "\n" }}
+        {{- tool | tojson }}
+    {%- endfor %}
+    {{- "\n</tools>\n\nFor each function call, return a json object with function name and arguments within <tool_call></tool_call> XML tags:\n<tool_call>\n{\"name\": <function-name>, \"arguments\": <args-json-object>}\n</tool_call><|im_end|>\n" }}
+{%- else %}
+    {%- if messages[0].role == 'system' %}
+        {{- '<|im_start|>system\n' }}
+        {%- if messages[0].content is string %}
+            {{- messages[0].content }}
+        {%- else %}
+            {%- for content in messages[0].content %}
+                {%- if 'text' in content %}
+                    {{- content.text }}
+                {%- endif %}
+            {%- endfor %}
+        {%- endif %}
+        {{- '<|im_end|>\n' }}
+    {%- endif %}
+{%- endif %}
+{%- set image_count = namespace(value=0) %}
+{%- set video_count = namespace(value=0) %}
+{%- for message in messages %}
+    {%- if message.role == "user" %}
+        {{- '<|im_start|>' + message.role + '\n' }}
+        {%- if message.content is string %}
+            {{- message.content }}
+        {%- else %}
+            {%- for content in message.content %}
+                {%- if content.type == 'image' or 'image' in content or 'image_url' in content %}
+                    {%- set image_count.value = image_count.value + 1 %}
+                    {%- if add_vision_id %}Picture {{ image_count.value }}: {% endif -%}
+                    <|vision_start|><|image_pad|><|vision_end|>
+                {%- elif content.type == 'video' or 'video' in content %}
+                    {%- set video_count.value = video_count.value + 1 %}
+                    {%- if add_vision_id %}Video {{ video_count.value }}: {% endif -%}
+                    <|vision_start|><|video_pad|><|vision_end|>
+                {%- elif 'text' in content %}
+                    {{- content.text }}
+                {%- endif %}
+            {%- endfor %}
+        {%- endif %}
+        {{- '<|im_end|>\n' }}
+    {%- elif message.role == "assistant" %}
+        {{- '<|im_start|>' + message.role + '\n' }}
+        {%- if message.content is string %}
+            {{- message.content }}
+        {%- else %}
+            {%- for content_item in message.content %}
+                {%- if 'text' in content_item %}
+                    {{- content_item.text }}
+                {%- endif %}
+            {%- endfor %}
+        {%- endif %}
+        {%- if message.tool_calls %}
+            {%- for tool_call in message.tool_calls %}
+                {%- if (loop.first and message.content) or (not loop.first) %}
+                    {{- '\n' }}
+                {%- endif %}
+                {%- if tool_call.function %}
+                    {%- set tool_call = tool_call.function %}
+                {%- endif %}
+                {{- '<tool_call>\n{"name": "' }}
+                {{- tool_call.name }}
+                {{- '", "arguments": ' }}
+                {%- if tool_call.arguments is string %}
+                    {{- tool_call.arguments }}
+                {%- else %}
+                    {{- tool_call.arguments | tojson }}
+                {%- endif %}
+                {{- '}\n</tool_call>' }}
+            {%- endfor %}
+        {%- endif %}
+        {{- '<|im_end|>\n' }}
+    {%- elif message.role == "tool" %}
+        {%- if loop.first or (messages[loop.index0 - 1].role != "tool") %}
+            {{- '<|im_start|>user' }}
+        {%- endif %}
+        {{- '\n<tool_response>\n' }}
+        {%- if message.content is string %}
+            {{- message.content }}
+        {%- else %}
+            {%- for content in message.content %}
+                {%- if content.type == 'image' or 'image' in content or 'image_url' in content %}
+                    {%- set image_count.value = image_count.value + 1 %}
+                    {%- if add_vision_id %}Picture {{ image_count.value }}: {% endif -%}
+                    <|vision_start|><|image_pad|><|vision_end|>
+                {%- elif content.type == 'video' or 'video' in content %}
+                    {%- set video_count.value = video_count.value + 1 %}
+                    {%- if add_vision_id %}Video {{ video_count.value }}: {% endif -%}
+                    <|vision_start|><|video_pad|><|vision_end|>
+                {%- elif 'text' in content %}
+                    {{- content.text }}
+                {%- endif %}
+            {%- endfor %}
+        {%- endif %}
+        {{- '\n</tool_response>' }}
+        {%- if loop.last or (messages[loop.index0 + 1].role != "tool") %}
+            {{- '<|im_end|>\n' }}
+        {%- endif %}
+    {%- endif %}
+{%- endfor %}
+{%- if add_generation_prompt %}
+    {{- '<|im_start|>assistant\n' }}
+{%- endif %}

config.json

@@ -0,0 +1,105 @@
+{
+  "architectures": [
+    "Qwen3VLForConditionalGeneration"
+  ],
+  "dtype": "bfloat16",
+  "image_token_id": 151655,
+  "model_type": "qwen3_vl",
+  "quantization_config": {
+    "algo_config": null,
+    "exclude": [],
+    "export": {
+      "kv_cache_group": [],
+      "min_kv_scale": 0.0,
+      "pack_method": "reorder",
+      "weight_format": "real_quantized",
+      "weight_merge_groups": null
+    },
+    "global_quant_config": {
+      "bias": null,
+      "input_tensors": null,
+      "output_tensors": null,
+      "target_device": null,
+      "weight": {
+        "ch_axis": -1,
+        "dtype": "uint4",
+        "group_size": 128,
+        "is_dynamic": false,
+        "is_scale_quant": false,
+        "mx_element_dtype": null,
+        "observer_cls": "PerGroupMinMaxObserver",
+        "qscheme": "per_group",
+        "round_method": "half_even",
+        "scale_calculation_mode": null,
+        "scale_format": null,
+        "scale_type": "float",
+        "symmetric": false
+      }
+    },
+    "kv_cache_post_rope": false,
+    "kv_cache_quant_config": {},
+    "layer_quant_config": {},
+    "layer_type_quant_config": {},
+    "quant_method": "quark",
+    "quant_mode": "eager_mode",
+    "softmax_quant_spec": null,
+    "version": "0.11"
+  },
+  "text_config": {
+    "attention_bias": false,
+    "attention_dropout": 0.0,
+    "bos_token_id": 151643,
+    "dtype": "bfloat16",
+    "eos_token_id": 151645,
+    "head_dim": 128,
+    "hidden_act": "silu",
+    "hidden_size": 2560,
+    "initializer_range": 0.02,
+    "intermediate_size": 9728,
+    "max_position_embeddings": 262144,
+    "model_type": "qwen3_vl_text",
+    "num_attention_heads": 32,
+    "num_hidden_layers": 36,
+    "num_key_value_heads": 8,
+    "rms_norm_eps": 1e-06,
+    "rope_scaling": {
+      "mrope_interleaved": true,
+      "mrope_section": [
+        24,
+        20,
+        20
+      ],
+      "rope_type": "default"
+    },
+    "rope_theta": 5000000,
+    "tie_word_embeddings": true,
+    "use_cache": true,
+    "vocab_size": 151936
+  },
+  "tie_word_embeddings": true,
+  "transformers_version": "4.57.0",
+  "video_token_id": 151656,
+  "vision_config": {
+    "deepstack_visual_indexes": [
+      5,
+      11,
+      17
+    ],
+    "depth": 24,
+    "dtype": "bfloat16",
+    "hidden_act": "gelu_pytorch_tanh",
+    "hidden_size": 1024,
+    "in_channels": 3,
+    "initializer_range": 0.02,
+    "intermediate_size": 4096,
+    "model_type": "qwen3_vl",
+    "num_heads": 16,
+    "num_position_embeddings": 2304,
+    "out_hidden_size": 2560,
+    "patch_size": 16,
+    "spatial_merge_size": 2,
+    "temporal_patch_size": 2
+  },
+  "vision_end_token_id": 151653,
+  "vision_start_token_id": 151652
+}

generation_config.json

@@ -0,0 +1,13 @@
+{
+  "bos_token_id": 151643,
+  "do_sample": true,
+  "eos_token_id": [
+    151645,
+    151643
+  ],
+  "pad_token_id": 151643,
+  "temperature": 0.7,
+  "top_k": 20,
+  "top_p": 0.8,
+  "transformers_version": "4.57.0"
+}

generation_test_results.txt

@@ -0,0 +1,12 @@
+Manual Text Generation Test Results
+==================================================
+
+Input: The capital of France is
+Output: The capital of France is Paris. The capital of Spain is Madrid. The capital of Italy is Rome. The capital of Germany
+
+Input: Python is a programming language that
+Output: Python is a programming language that is easy to learn and use. It is a high-level, interpreted language, which means that it
+
+Input: Machine learning is
+Output: Machine learning is a subset of artificial intelligence (AI) that enables computers to learn from data and make predictions or decisions
+

model.safetensors

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

run_qwen3_vl_4b_quant_model.py

@@ -0,0 +1,281 @@
+import sys
+import os
+import torch
+import copy
+import argparse
+
+sys.path.append(os.path.abspath(os.path.join(os.path.dirname(__file__), '..')))
+from transformers import AutoConfig, AutoTokenizer, AutoProcessor, PreTrainedTokenizer
+
+from quark.torch import (
+    LLMTemplate,
+    ModelQuantizer,
+    export_safetensors,
+    import_model_from_safetensors,
+)
+
+from quark.torch.utils.llm import (
+    get_calib_dataloader,
+)
+
+# Import the correct model class
+try:
+    from transformers import Qwen3VLForConditionalGeneration
+    model_class = Qwen3VLForConditionalGeneration
+    print("Using Qwen3VLForConditionalGeneration")
+except ImportError:
+    print("Failed to load the model using Qwen3_VLForConditionalGeneration")
+
+
+def parse_args():
+    parser = argparse.ArgumentParser(description='Quantize Qwen3-VL model with various configurations')
+    
+    # Model paths
+    parser.add_argument('--model_dir', type=str, default='/scratch/dwchenna/github/hf-models/Qwen3-VL-4B-Instruct',
+                        help='Path to the input model directory')
+    parser.add_argument('--output_dir', type=str, default='quantized_models/Qwen3-VL-4B-Instruct-per-grp-quant',
+                        help='Output directory for quantized model')
+    
+    # Evaluation options
+    parser.add_argument('--eval_float', action='store_true', default=False,
+                        help='Evaluate original float model')
+    parser.add_argument('--eval_quantized', action='store_true', default=False,
+                        help='Evaluate quantized model')
+    parser.add_argument('--skip_quantization', action='store_true',
+                        help='Skip quantization and only evaluate existing models')
+    
+    # Device
+    parser.add_argument('--device', type=str, default='cuda' if torch.cuda.is_available() else 'cpu',
+                        help='Device to use for computation')
+    
+    return parser.parse_args()
+
+
+args = parse_args()
+
+# Setup
+model_dir = args.model_dir
+model_out_dir = args.output_dir
+device = args.device
+
+print(f"Device: {device}")
+print("Loading model...")
+
+# Load config, tokenizer, processor
+config = AutoConfig.from_pretrained(model_dir, trust_remote_code=True)
+tokenizer = AutoTokenizer.from_pretrained(model_dir, trust_remote_code=True)
+processor = AutoProcessor.from_pretrained(model_dir, trust_remote_code=True)
+
+# Load model
+model = model_class.from_pretrained(
+    model_dir, 
+    trust_remote_code=True, 
+    torch_dtype=torch.bfloat16,
+    device_map="cpu"
+).to(device)
+
+print(f"Model loaded: {model.__class__.__name__}")
+model.eval()
+
+# Create a deep copy before quantization to preserve the original float model
+float_model = copy.deepcopy(model)
+# Filter out visual part
+# del model.visual
+print(model)
+
+# Create output directory
+os.makedirs(model_out_dir, exist_ok=True)
+tokenizer.save_pretrained(model_out_dir)
+
+# Get model type
+model_config_type = (
+    model.config.model_type if hasattr(model.config, "model_type") else model.config.architectures[0]
+)
+print(f"Model config type: {model_config_type}")
+
+# Register template for qwen3_vl if needed
+if model_config_type == "qwen3_vl":
+    qwen3_vl_template = LLMTemplate(
+        model_type="qwen3_vl",
+        kv_layers_name=["model.layers.*.self_attn.q_proj", 
+                       "model.layers.*.self_attn.k_proj", 
+                       "model.layers.*.self_attn.v_proj"],
+        q_layer_name="model.layers.*.self_attn.q_proj",
+        exclude_layers_name=["visual*", "*vision*"],
+    )
+    LLMTemplate.register_template(qwen3_vl_template)
+    print(f"Registered template for '{qwen3_vl_template.model_type}'")
+
+# Check if model type is supported
+if model_config_type not in LLMTemplate.list_available():
+    print(f"Available templates: {LLMTemplate.list_available()}")
+    raise ValueError(f"Model type '{model_config_type}' is not supported.")
+
+template = LLMTemplate.get(model_config_type)
+print(f"Using template: {model_config_type}")
+
+# Quantization configuration
+quant_scheme = "uint4_wo_128"
+quant_algo = None # "awq"
+exclude_layers = ["visual*", "*vision*"]
+
+quant_config = template.get_config(
+    scheme=quant_scheme,
+    algorithm=quant_algo,
+    exclude_layers=exclude_layers,
+)
+
+print(f"Quantization config: {quant_config}")
+
+# Quantization section
+if not args.skip_quantization:
+    # Create calibration dataloader
+    print("Loading calibration dataset...")
+    main_device = model.device
+    dataset = "pileval_for_awq_benchmark"
+    batch_size = 1
+    num_calib_data = 128
+    seq_len = 512
+
+    calib_dataloader = get_calib_dataloader(
+        dataset_name=dataset,
+        processor=None,  # Set to None to avoid multimodal issues
+        tokenizer=tokenizer,
+        batch_size=batch_size,
+        num_calib_data=num_calib_data,
+        seqlen=seq_len,
+        device=main_device,
+    )
+
+    # Quantize model
+    print("Starting quantization...")
+    try:
+        quantizer = ModelQuantizer(quant_config)
+        model = quantizer.quantize_model(model, calib_dataloader)
+        
+        # Freeze model
+        model = quantizer.freeze(model)
+        print("✓ Quantization completed successfully!")
+        
+        # Export quantized model
+        print("Exporting quantized model...")
+        with torch.no_grad():
+            export_safetensors(
+                model=model,
+                output_dir=model_out_dir,
+                custom_mode="quark",
+                weight_format="real_quantized",
+                pack_method="reorder",
+            )
+        
+        print(f"✓ Model exported to: {model_out_dir}")
+        
+    except Exception as e:
+        print(f"✗ Quantization failed: {e}")
+        print("This is likely due to AWQ not being compatible with multimodal models.")
+        print("Try using a simpler quantization scheme without AWQ.")
+
+    print("Quantization script completed!")
+else:
+    print("[INFO]: Skipping quantization as requested")
+
+# Evaluation section
+print("\n" + "="*60)
+print("MODEL EVALUATION")
+print("="*60)
+
+if args.eval_float or args.eval_quantized:
+    # Load quantized model if needed for evaluation
+    model_quant = None
+    if args.eval_quantized:
+        print("Loading quantized model...")
+        try:
+            # Load a fresh model instance first
+            fresh_model = model_class.from_pretrained(
+                model_dir,  # Use original model dir for architecture
+                trust_remote_code=True, 
+                torch_dtype=torch.bfloat16,
+                device_map="cpu"
+            )
+            # Load quantized weights using Quark's import function
+            model_quant = import_model_from_safetensors(
+                model=fresh_model,  
+                model_dir=model_out_dir  # Directory with quantized safetensors
+            )
+            model_quant = model_quant.to(device)
+            print("Successfully loaded quantized model from safetensors")
+            print(f"Model type: {type(model_quant)}")
+        except Exception as e:
+            print(f"✗ Failed to load from {model_out_dir}: {e}")
+            if not args.skip_quantization:
+                print("Using the quantized model directly from memory...")
+                model_quant = model
+            else:
+                print("[WARNING]: No quantized model available for evaluation")
+                args.eval_quantized = False
+
+    # Load the evaluation dataset
+    from datasets import Dataset, load_dataset
+    testdata = load_dataset("wikitext", "wikitext-2-raw-v1", split="test")
+    
+    # Use tokenizer from model directory or output directory
+    tokenizer_path = model_out_dir if os.path.exists(model_out_dir) else model_dir
+    tokenizer: PreTrainedTokenizer = AutoTokenizer.from_pretrained(  # type: ignore
+        tokenizer_path,
+        trust_remote_code=True,
+    )
+    
+    # Load the test dataset
+    testenc = tokenizer("\n\n".join(testdata["text"]), return_tensors="pt")
+    
+    # Results storage
+    results = {}
+    
+    from quark.contrib.llm_eval import ppl_eval
+    
+    # Evaluate original float model
+    if args.eval_float:
+        print("\n[INFO]: Evaluating original float model...")
+        print("-" * 40)
+        try:
+            main_device = float_model.device
+            ppl_float = ppl_eval(float_model, testenc, main_device)
+            ppl_float_value = ppl_float.item()
+            results['float_ppl'] = ppl_float_value
+            print(f"[RESULT] Float Model Perplexity: {ppl_float_value:.4f}")
+        except Exception as e:
+            print(f"[ERROR] Float model evaluation failed: {e}")
+            results['float_ppl'] = None
+    
+    # Evaluate quantized model
+    if args.eval_quantized and model_quant is not None:
+        print("\n[INFO]: Evaluating quantized model...")
+        print("-" * 40)
+        try:
+            main_device = model_quant.device
+            ppl_quant = ppl_eval(model_quant, testenc, main_device)
+            ppl_quant_value = ppl_quant.item()
+            results['quantized_ppl'] = ppl_quant_value
+            print(f"[RESULT] Quantized Model Perplexity: {ppl_quant_value:.4f}")
+        except Exception as e:
+            print(f"[ERROR] Quantized model evaluation failed: {e}")
+            results['quantized_ppl'] = None
+    
+    # Summary
+    print("\n" + "="*60)
+    print("EVALUATION SUMMARY")
+    print("="*60)
+    print(f"Model: {model_dir}")
+    print(f"Output: {model_out_dir}")
+    
+    if 'float_ppl' in results and results['float_ppl'] is not None:
+        print(f"Float Model Perplexity: {results['float_ppl']:.4f}")
+    
+    if 'quantized_ppl' in results and results['quantized_ppl'] is not None:
+        print(f"Quantized Model Perplexity: {results['quantized_ppl']:.4f}")
+    
+    print("="*60)
+else:
+    print("\n[INFO]: Skipping evaluation as requested")
+
+print("\n[INFO]: Script completed successfully!")

special_tokens_map.json

@@ -0,0 +1,31 @@
+{
+  "additional_special_tokens": [
+    "<|im_start|>",
+    "<|im_end|>",
+    "<|object_ref_start|>",
+    "<|object_ref_end|>",
+    "<|box_start|>",
+    "<|box_end|>",
+    "<|quad_start|>",
+    "<|quad_end|>",
+    "<|vision_start|>",
+    "<|vision_end|>",
+    "<|vision_pad|>",
+    "<|image_pad|>",
+    "<|video_pad|>"
+  ],
+  "eos_token": {
+    "content": "<|im_end|>",
+    "lstrip": false,
+    "normalized": false,
+    "rstrip": false,
+    "single_word": false
+  },
+  "pad_token": {
+    "content": "<|endoftext|>",
+    "lstrip": false,
+    "normalized": false,
+    "rstrip": false,
+    "single_word": false
+  }
+}

tokenizer.json

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

tokenizer_config.json

@@ -0,0 +1,239 @@
+{
+  "add_bos_token": false,
+  "add_prefix_space": false,
+  "added_tokens_decoder": {
+    "151643": {
+      "content": "<|endoftext|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "151644": {
+      "content": "<|im_start|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "151645": {
+      "content": "<|im_end|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "151646": {
+      "content": "<|object_ref_start|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "151647": {
+      "content": "<|object_ref_end|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "151648": {
+      "content": "<|box_start|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "151649": {
+      "content": "<|box_end|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "151650": {
+      "content": "<|quad_start|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "151651": {
+      "content": "<|quad_end|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "151652": {
+      "content": "<|vision_start|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "151653": {
+      "content": "<|vision_end|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "151654": {
+      "content": "<|vision_pad|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "151655": {
+      "content": "<|image_pad|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "151656": {
+      "content": "<|video_pad|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "151657": {
+      "content": "<tool_call>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": false
+    },
+    "151658": {
+      "content": "</tool_call>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": false
+    },
+    "151659": {
+      "content": "<|fim_prefix|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": false
+    },
+    "151660": {
+      "content": "<|fim_middle|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": false
+    },
+    "151661": {
+      "content": "<|fim_suffix|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": false
+    },
+    "151662": {
+      "content": "<|fim_pad|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": false
+    },
+    "151663": {
+      "content": "<|repo_name|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": false
+    },
+    "151664": {
+      "content": "<|file_sep|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": false
+    },
+    "151665": {
+      "content": "<tool_response>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": false
+    },
+    "151666": {
+      "content": "</tool_response>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": false
+    },
+    "151667": {
+      "content": "<think>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": false
+    },
+    "151668": {
+      "content": "</think>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": false
+    }
+  },
+  "additional_special_tokens": [
+    "<|im_start|>",
+    "<|im_end|>",
+    "<|object_ref_start|>",
+    "<|object_ref_end|>",
+    "<|box_start|>",
+    "<|box_end|>",
+    "<|quad_start|>",
+    "<|quad_end|>",
+    "<|vision_start|>",
+    "<|vision_end|>",
+    "<|vision_pad|>",
+    "<|image_pad|>",
+    "<|video_pad|>"
+  ],
+  "bos_token": null,
+  "clean_up_tokenization_spaces": false,
+  "eos_token": "<|im_end|>",
+  "errors": "replace",
+  "extra_special_tokens": {},
+  "model_max_length": 262144,
+  "pad_token": "<|endoftext|>",
+  "split_special_tokens": false,
+  "tokenizer_class": "Qwen2Tokenizer",
+  "unk_token": null
+}

vocab.json

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