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

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,85 @@
+{%- if tools %}
+    {{- '<|im_start|>system\n' }}
+    {%- if messages[0].role == 'system' %}
+        {{- messages[0].content + '\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' + messages[0].content + '<|im_end|>\n' }}
+    {%- endif %}
+{%- endif %}
+{%- set ns = namespace(multi_step_tool=true, last_query_index=messages|length - 1) %}
+{%- for message in messages[::-1] %}
+    {%- set index = (messages|length - 1) - loop.index0 %}
+    {%- if ns.multi_step_tool and message.role == "user" and not(message.content.startswith('<tool_response>') and message.content.endswith('</tool_response>')) %}
+        {%- set ns.multi_step_tool = false %}
+        {%- set ns.last_query_index = index %}
+    {%- endif %}
+{%- endfor %}
+{%- for message in messages %}
+    {%- if (message.role == "user") or (message.role == "system" and not loop.first) %}
+        {{- '<|im_start|>' + message.role + '\n' + message.content + '<|im_end|>' + '\n' }}
+    {%- elif message.role == "assistant" %}
+        {%- set content = message.content %}
+        {%- set reasoning_content = '' %}
+        {%- if message.reasoning_content is defined and message.reasoning_content is not none %}
+            {%- set reasoning_content = message.reasoning_content %}
+        {%- else %}
+            {%- if '</think>' in message.content %}
+                {%- set content = message.content.split('</think>')[-1].lstrip('\n') %}
+                {%- set reasoning_content = message.content.split('</think>')[0].rstrip('\n').split('<think>')[-1].lstrip('\n') %}
+            {%- endif %}
+        {%- endif %}
+        {%- if loop.index0 > ns.last_query_index %}
+            {%- if loop.last or (not loop.last and reasoning_content) %}
+                {{- '<|im_start|>' + message.role + '\n<think>\n' + reasoning_content.strip('\n') + '\n</think>\n\n' + content.lstrip('\n') }}
+            {%- else %}
+                {{- '<|im_start|>' + message.role + '\n' + content }}
+            {%- endif %}
+        {%- else %}
+            {{- '<|im_start|>' + message.role + '\n' + content }}
+        {%- endif %}
+        {%- if message.tool_calls %}
+            {%- for tool_call in message.tool_calls %}
+                {%- if (loop.first and 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' }}
+        {{- message.content }}
+        {{- '\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' }}
+    {%- if enable_thinking is defined and enable_thinking is false %}
+        {{- '<think>\n\n</think>\n\n' }}
+    {%- endif %}
+{%- endif %}

config.json

@@ -0,0 +1,64 @@
+{
+  "_moe_implementation": "fused",
+  "architectures": [
+    "BailingMoeV2ForCausalLM"
+  ],
+  "attention_dropout": 0.0,
+  "auto_map": {
+    "AutoConfig": "configuration_bailing_moe_v2.BailingMoeV2Config",
+    "AutoModel": "modeling_bailing_moe_v2.BailingMoeV2Model",
+    "AutoModelForCausalLM": "modeling_bailing_moe_v2.BailingMoeV2ForCausalLM"
+  },
+  "bos_token_id": 151643,
+  "dtype": "bfloat16",
+  "embedding_dropout": 0.0,
+  "eos_token_id": 151645,
+  "first_k_dense_replace": 1,
+  "head_dim": 128,
+  "hidden_act": "silu",
+  "hidden_size": 2048,
+  "initializer_range": 0.02,
+  "intermediate_size": 5120,
+  "max_position_embeddings": 32768,
+  "max_window_layers": 20,
+  "moe_intermediate_size": 512,
+  "moe_router_enable_expert_bias": true,
+  "moe_shared_expert_intermediate_size": 512,
+  "mtp_loss_scaling_factor": 0,
+  "n_group": 8,
+  "norm_topk_prob": true,
+  "num_attention_heads": 16,
+  "num_experts": 224,
+  "num_experts_per_tok": 8,
+  "num_hidden_layers": 30,
+  "num_key_value_heads": 4,
+  "num_nextn_predict_layers": 0,
+  "num_shared_experts": null,
+  "output_dropout": 0.0,
+  "output_router_logits": true,
+  "pad_token_id": null,
+  "partial_rotary_factor": 0.5,
+  "pruning_info": {
+    "original_experts": 256,
+    "original_model_path": "5kling-fuse_heal",
+    "pruned_experts": 224,
+    "pruning_date": "2026-01-16T05:26:11.661656",
+    "pruning_method": "MoP"
+  },
+  "quantize": false,
+  "rms_norm_eps": 1e-06,
+  "rope_scaling": null,
+  "rope_theta": 600000,
+  "routed_scaling_factor": 2.5,
+  "router_dtype": "fp32",
+  "score_function": "sigmoid",
+  "tie_word_embeddings": false,
+  "topk_group": 4,
+  "transformers_version": "4.57.3",
+  "use_bias": false,
+  "use_cache": true,
+  "use_qk_norm": true,
+  "use_qkv_bias": false,
+  "use_rmsnorm": true,
+  "vocab_size": 151936
+}

configuration_bailing_moe_v2.py

@@ -0,0 +1,84 @@
+"""Bailing MoE V2 model configuration"""
+
+from transformers.configuration_utils import PretrainedConfig
+
+
+class BailingMoeV2Config(PretrainedConfig):
+
+    def __init__(
+        self,
+        vocab_size=157184,
+        hidden_size=2048,
+        intermediate_size=5120,
+        num_hidden_layers=20,
+        num_attention_heads=16,
+        num_key_value_heads=4,
+        hidden_act="silu",
+        use_qkv_bias=False,  # bailing only
+        use_bias=False,  # bailing only
+        rms_norm_eps=1e-06,
+        tie_word_embeddings=False,  # PretrainedConfig key, here change default value.
+        embedding_dropout=0.0,
+        attention_dropout=0.0,
+        output_dropout=0.0,
+        initializer_range=0.02,
+        max_position_embeddings=32768,
+        rope_theta=600000.0,
+        use_cache=True,
+        max_window_layers=20,
+        rope_scaling=None,
+        pad_token_id=156892,
+        eos_token_id=156892,
+        num_experts=256,
+        num_shared_experts=1,
+        num_experts_per_tok=8,
+        n_group=8,
+        topk_group=4,
+        moe_intermediate_size=512,
+        first_k_dense_replace=1,
+        head_dim=128,
+        output_router_logits=False,
+        use_qk_norm=True,
+        num_nextn_predict_layers=0,
+        mtp_loss_scaling_factor=0,
+        moe_router_enable_expert_bias=True,
+        routed_scaling_factor=1.0,
+        **kwargs,
+    ):
+        self.num_hidden_layers = num_hidden_layers
+        self.vocab_size = vocab_size
+        self.hidden_size = hidden_size
+        self.intermediate_size = intermediate_size
+        self.num_attention_heads = num_attention_heads
+        self.num_key_value_heads = num_key_value_heads
+        self.hidden_act = hidden_act
+        self.use_qkv_bias = use_qkv_bias
+        self.use_bias = use_bias
+        self.rms_norm_eps = rms_norm_eps
+        self.embedding_dropout = embedding_dropout
+        self.attention_dropout = attention_dropout
+        self.output_dropout = output_dropout
+        self.num_nextn_predict_layers = num_nextn_predict_layers
+        self.mtp_loss_scaling_factor = mtp_loss_scaling_factor
+        self.initializer_range = initializer_range
+        self.max_position_embeddings = max_position_embeddings
+        self.rope_theta = rope_theta
+        self.use_cache = use_cache
+        self.max_window_layers = max_window_layers
+        self.head_dim = head_dim or self.hidden_size // self.num_attention_heads
+        self.rope_scaling = rope_scaling
+        self.use_qk_norm = use_qk_norm
+        self.moe_router_enable_expert_bias = moe_router_enable_expert_bias
+        self.routed_scaling_factor = routed_scaling_factor
+
+        # MoE configs
+        self.num_experts = num_experts
+        self.num_shared_experts = num_shared_experts
+        self.num_experts_per_tok = num_experts_per_tok
+        self.n_group = n_group
+        self.topk_group = topk_group
+        self.moe_intermediate_size = moe_intermediate_size
+        self.first_k_dense_replace = first_k_dense_replace
+        self.output_router_logits = output_router_logits
+
+        super().__init__(pad_token_id=pad_token_id, eos_token_id=eos_token_id, tie_word_embeddings=tie_word_embeddings, **kwargs)

model.safetensors

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

smart_upcycle.py

@@ -0,0 +1,344 @@
+#!/usr/bin/env python3
+"""
+Smart Importance-Based MoE Upcycler (v2.1 - Strict MoE Detection)
+
+Updates:
+- FIXED: Layer 0 (Dense) misidentification. Now distinguishes between SwiGLU gates and MoE Routers.
+- ENFORCED: Model 2 (The Stack) strictly forbids Dense layers.
+
+Usage:
+    python smart_upcycle.py \
+        --model_path inclusionAI/Ling-mini-2.0 \
+        --output_path ./ling-mini-30L-upcycled \
+        --target_layers 30 \
+        --model1_ratio 0.55
+
+Author: Claude (Anthropic)
+"""
+
+import argparse
+import os
+import shutil
+import gc
+import logging
+from pathlib import Path
+from typing import Dict, List, Tuple
+from collections import defaultdict
+
+# Configure logging
+logging.basicConfig(
+    level=logging.INFO,
+    format='%(asctime)s - [%(levelname)s] - %(message)s',
+    datefmt='%H:%M:%S'
+)
+logger = logging.getLogger("SmartUpcycler")
+
+try:
+    import torch
+    import torch.nn as nn
+    from transformers import AutoConfig, AutoModelForCausalLM, AutoTokenizer
+    from safetensors.torch import save_file
+    from datasets import load_dataset
+    from tqdm import tqdm
+except ImportError as e:
+    logger.error(f"Missing dependency: {e}")
+    logger.error("pip install torch transformers safetensors datasets tqdm accelerate")
+    exit(1)
+
+class LayerAnalyzer:
+    """Analyzes model layers with strict MoE vs Dense differentiation."""
+
+    def __init__(self, model, tokenizer, device='cuda'):
+        self.model = model
+        self.tokenizer = tokenizer
+        self.device = device
+        self.layer_data = defaultdict(list)
+        self.hooks = []
+
+    def get_layers(self):
+        if hasattr(self.model, 'model') and hasattr(self.model.model, 'layers'):
+            return self.model.model.layers
+        elif hasattr(self.model, 'layers'):
+            return self.model.layers
+        else:
+            raise ValueError("Unsupported model architecture: cannot find .layers")
+
+    def identify_layer_types(self) -> Tuple[List[int], List[int]]:
+        """
+        Scans architecture with heuristic specifically tuned to avoid SwiGLU false positives.
+        Returns: (moe_indices, dense_indices)
+        """
+        moe_indices = []
+        dense_indices = []
+        layers = self.get_layers()
+
+        for idx, layer in enumerate(layers):
+            is_moe = False
+            
+            # 1. Find the MLP module
+            # Common names: mlp, block_sparse_moe, feed_forward
+            candidates = ['mlp', 'block_sparse_moe', 'feed_forward', 'ffn']
+            module = None
+            for name in candidates:
+                if hasattr(layer, name):
+                    module = getattr(layer, name)
+                    break
+            
+            if module is not None:
+                # 2. Strict MoE Check
+                # We do NOT check for 'gate' alone because SwiGLU has 'gate_proj'
+                has_experts_list = hasattr(module, 'experts') and len(module.experts) > 1
+                has_num_experts = hasattr(module, 'num_experts') and module.num_experts > 1
+                
+                # Check class name for explicit "MoE" string
+                class_name = type(module).__name__.lower()
+                name_is_moe = 'moe' in class_name or 'sparse' in class_name
+
+                if has_experts_list or has_num_experts or name_is_moe:
+                    is_moe = True
+                if idx == 0:
+                    is_moe = False
+            
+            if is_moe:
+                moe_indices.append(idx)
+            else:
+                dense_indices.append(idx)
+
+        # Sanity check for user
+        if 0 in moe_indices:
+            logger.warning("Warning: Layer 0 identified as MoE. This is rare. Verify model architecture.")
+
+        return moe_indices, dense_indices
+
+    def compute_importance(self, calibration_data: List[str]) -> Dict[int, float]:
+        """
+        Calculates layer importance using Cosine Similarity.
+        Score = 1.0 - CosSim(Input, Output)
+        """
+        logger.info(f"Computing importance using {len(calibration_data)} samples...")
+        layers = self.get_layers()
+        
+        def get_activation_hook(idx):
+            def hook(module, input, output):
+                if isinstance(input, tuple): inp = input[0]
+                else: inp = input
+                if isinstance(output, tuple): out = output[0]
+                else: out = output
+
+                with torch.no_grad():
+                    # Flatten to [Batch * Seq, Hidden]
+                    inp_flat = inp.view(-1, inp.size(-1)).float()
+                    out_flat = out.view(-1, out.size(-1)).float()
+                    
+                    # Compute mean cosine similarity for this batch
+                    cos = torch.nn.functional.cosine_similarity(inp_flat.to("cuda"), out_flat.to("cuda"), dim=-1)
+                    # Higher similarity = Lower importance
+                    score = 1.0 - cos.mean().item()
+                    self.layer_data[idx].append(score)
+            return hook
+
+        for idx, layer in enumerate(layers):
+            self.hooks.append(layer.register_forward_hook(get_activation_hook(idx)))
+
+        self.model.eval()
+        with torch.no_grad():
+            for text in tqdm(calibration_data, desc="Calibrating"):
+                inputs = self.tokenizer(text, return_tensors="pt", truncation=True, max_length=512)
+                inputs = {k: v.to(self.device) for k, v in inputs.items()}
+                self.model(**inputs)
+
+        final_scores = {}
+        for idx, scores in self.layer_data.items():
+            final_scores[idx] = sum(scores) / len(scores)
+
+        for h in self.hooks: h.remove()
+        self.layer_data.clear()
+        
+        return final_scores
+
+class SmartUpcycler:
+    def __init__(self, model_path: str, device: str = 'auto'):
+        self.model_path = model_path
+        self.device = device
+        self.config = AutoConfig.from_pretrained(model_path, trust_remote_code=True)
+        self.tokenizer = AutoTokenizer.from_pretrained(model_path, trust_remote_code=True)
+        
+    def load_model(self):
+        logger.info(f"Loading model from {self.model_path}...")
+        return AutoModelForCausalLM.from_pretrained(
+            self.model_path,
+            torch_dtype=torch.bfloat16,
+            device_map=self.device,
+            trust_remote_code=True,
+            low_cpu_mem_usage=True
+        )
+
+    def create_layer_plan(self, 
+                         importance_scores: Dict[int, float], 
+                         moe_indices: List[int],
+                         dense_indices: List[int],
+                         total_original: int,
+                         target_total: int,
+                         m1_count: int,
+                         m2_count: int) -> Tuple[List[int], List[int]]:
+        
+        # --- Model 1 (Base) ---
+        # Strategy: Keep First 2, Last 2 (Stability), then fill with best remaining layers (Dense OR MoE)
+        structural_layers = {0, 1, total_original-2, total_original-1}
+        m1_candidates = [i for i in range(total_original) if i not in structural_layers]
+        
+        # Sort by importance
+        m1_candidates.sort(key=lambda x: importance_scores.get(x, 0), reverse=True)
+        
+        needed_m1 = m1_count - len(structural_layers)
+        selected_m1 = list(structural_layers) + m1_candidates[:max(0, needed_m1)]
+        selected_m1.sort()
+        
+        # --- Model 2 (Extension) ---
+        # Strategy: STRICTLY MoE layers only.
+        
+        if not moe_indices:
+            raise ValueError("Model has no MoE layers! Cannot fulfill constraint.")
+
+        # Filter: Only consider layers that are actually MoE
+        m2_candidates = [i for i in moe_indices]
+        m2_candidates.sort(key=lambda x: importance_scores.get(x, 0), reverse=True)
+        
+        selected_m2 = m2_candidates[:m2_count]
+        selected_m2.sort()
+
+        # Handle shortage by duplication if necessary
+        if len(selected_m2) < m2_count:
+            logger.warning(f"Not enough unique MoE layers (Found {len(selected_m2)}, Needed {m2_count}).")
+            logger.warning("Recycling top MoE layers to fill the gap.")
+            while len(selected_m2) < m2_count:
+                # Cycle through the best available MoE layers again
+                for candidate in m2_candidates:
+                    selected_m2.append(candidate)
+                    if len(selected_m2) == m2_count: break
+        
+        return selected_m1, selected_m2
+
+    def build_and_save(self, 
+                      original_state_dict, 
+                      m1_layers: List[int], 
+                      m2_layers: List[int], 
+                      output_path: Path):
+        
+        logger.info("Constructing new state dictionary...")
+        new_state_dict = {}
+        
+        # Helper to map keys
+        def map_layer(src_idx, dst_idx):
+            src_prefix = f"model.layers.{src_idx}."
+            dst_prefix = f"model.layers.{dst_idx}."
+            
+            for key, tensor in original_state_dict.items():
+                if key.startswith(src_prefix):
+                    new_key = key.replace(src_prefix, dst_prefix)
+                    new_state_dict[new_key] = tensor.clone()
+
+        # 1. Copy Non-Layer Weights
+        for key, tensor in original_state_dict.items():
+            if "layers." not in key:
+                new_state_dict[key] = tensor.clone()
+
+        # 2. Stack Model 1
+        current_layer_idx = 0
+        print(f"\n{'='*25} STACK PLAN {'='*25}")
+        print(f"{'Order':<5} | {'Dest':<5} | {'Source':<6} | {'Type'}")
+        print("-" * 50)
+        
+        for src in m1_layers:
+            map_layer(src, current_layer_idx)
+            print(f"{'M1':<5} | {current_layer_idx:<5} <- {src:<6} | {'Base Mixed'}")
+            current_layer_idx += 1
+
+        # 3. Stack Model 2
+        for src in m2_layers:
+            map_layer(src, current_layer_idx)
+            print(f"{'M2':<5} | {current_layer_idx:<5} <- {src:<6} | {'MoE ONLY'}")
+            current_layer_idx += 1
+            
+        # 4. Save
+        output_path.mkdir(parents=True, exist_ok=True)
+        self.config.num_hidden_layers = current_layer_idx
+        self.config.save_pretrained(output_path)
+        self.tokenizer.save_pretrained(output_path)
+        
+        logger.info(f"Saving model.safetensors to {output_path}...")
+        save_file(new_state_dict, os.path.join(output_path, "model.safetensors"))
+        shutil.copy(__file__, output_path)
+
+def load_calibration_samples(name='wikitext', split='train', n=128):
+    try:
+        data = load_dataset(name, 'wikitext-2-raw-v1', split=split, trust_remote_code=True)
+        samples = []
+        for x in data:
+            if len(x['text']) > 200:
+                samples.append(x['text'])
+                if len(samples) >= n: break
+        return samples
+    except Exception:
+        logger.warning("Could not load wikitext. Using dummy data.")
+        return ["Calibration string." * 50] * n
+
+def main():
+    parser = argparse.ArgumentParser(description="Smart MoE Upcycler")
+    parser.add_argument('--model_path', type=str, required=True)
+    parser.add_argument('--output_path', type=str, required=True)
+    parser.add_argument('--target_layers', type=int, default=30)
+    parser.add_argument('--model1_ratio', type=float, default=0.55)
+    parser.add_argument('--no_calibration', action='store_true')
+    args = parser.parse_args()
+
+    # 1. Setup
+    m1_count = int(args.target_layers * args.model1_ratio)
+    m2_count = args.target_layers - m1_count
+    
+    logger.info(f"Target: {args.target_layers} Layers. Split: M1={m1_count}, M2={m2_count} (Strict MoE)")
+
+    upcycler = SmartUpcycler(args.model_path)
+    model = upcycler.load_model()
+    
+    # 2. Analyze
+    analyzer = LayerAnalyzer(model, upcycler.tokenizer)
+    moe_indices, dense_indices = analyzer.identify_layer_types()
+    
+    logger.info(f"Scan Results: {len(moe_indices)} MoE layers, {len(dense_indices)} Dense layers.")
+    if len(dense_indices) > 0:
+        logger.info(f"Verified Dense Layers: {dense_indices}")
+    
+    # 3. Compute Importance
+    if args.no_calibration:
+        logger.info("Skipping calibration. Using uniform importance.")
+        total_orig = len(model.model.layers)
+        scores = {i: 1.0 for i in range(total_orig)}
+    else:
+        samples = load_calibration_samples()
+        scores = analyzer.compute_importance(samples)
+
+    # 4. Plan
+    m1_layers, m2_layers = upcycler.create_layer_plan(
+        scores, 
+        moe_indices, 
+        dense_indices,
+        len(model.model.layers),
+        args.target_layers,
+        m1_count, 
+        m2_count
+    )
+
+    # 5. Execute
+    logger.info("Moving model to CPU...")
+    model.cpu()
+    state_dict = model.state_dict()
+    if torch.cuda.is_available():
+        torch.cuda.empty_cache()
+        gc.collect()
+        
+    upcycler.build_and_save(state_dict, m1_layers, m2_layers, Path(args.output_path))
+    logger.info("Done.")
+
+if __name__ == "__main__":
+    main()

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:352a863cd2761388ccc58f1432467ba6a1037bf12df9069889b142fa246471f6
+size 11422752

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": 131072,
+  "pad_token": "<|endoftext|>",
+  "split_special_tokens": false,
+  "tokenizer_class": "Qwen2Tokenizer",
+  "unk_token": null
+}