Upload 9 files

.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,9 @@
+{
+  "</think>": 166104,
+  "</tool_call>": 166106,
+  "<think>": 166103,
+  "<tool_call>": 166105,
+  "<|endoftext|>": 166102,
+  "<|im_end|>": 166101,
+  "<|im_start|>": 166100
+}

config.json

@@ -0,0 +1,39 @@
+{
+  "architectures": [
+    "NanbeigeForCausalLM"
+  ],
+  "attention_bias": false,
+  "attention_dropout": 0.0,
+  "auto_map": {
+    "AutoConfig": "configuration_nanbeige.NanbeigeConfig",
+    "AutoModel": "modeling_nanbeige.NanbeigeModel",
+    "AutoModelForCausalLM": "modeling_nanbeige.NanbeigeForCausalLM"
+  },
+  "bos_token_id": 166100,
+  "eos_token_id": 166101,
+  "head_dim": 128,
+  "hidden_act": "silu",
+  "hidden_size": 3072,
+  "initializer_range": 0.02,
+  "intermediate_size": 10752,
+  "kv_channels": 128,
+  "loop_loss_weights": [],
+  "max_length": null,
+  "max_position_embeddings": 262144,
+  "model_type": "nanbeige",
+  "num_attention_heads": 48,
+  "num_hidden_layers": 22,
+  "num_key_value_heads": 8,
+  "num_loops": 2,
+  "pad_token_id": 0,
+  "pretraining_tp": 1,
+  "rms_norm_eps": 1e-05,
+  "rope_scaling": null,
+  "rope_theta": 70000000,
+  "skip_loop_final_norm": false,
+  "tie_word_embeddings": false,
+  "torch_dtype": "bfloat16",
+  "transformers_version": "4.42.4",
+  "use_cache": false,
+  "vocab_size": 166144
+}

configuration_nanbeige.py

@@ -0,0 +1,364 @@
+# coding=utf-8
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+"""Nanbeige model configuration."""
+
+from transformers.configuration_utils import PretrainedConfig
+from transformers.utils import logging
+
+
+logger = logging.get_logger(__name__)
+
+
+class NanbeigeConfig(PretrainedConfig):
+    r"""
+    This is the configuration class to store the configuration of a [`NanbeigeModel`]. It is used to instantiate an LLaMA
+    model according to the specified arguments, defining the model architecture. Instantiating a configuration with the
+    defaults will yield a similar configuration to that of the LLaMA-7B.
+
+    Configuration objects inherit from [`PretrainedConfig`] and can be used to control the model outputs. Read the
+    documentation from [`PretrainedConfig`] for more information.
+
+
+    Args:
+        vocab_size (`int`, *optional*, defaults to 32000):
+            Vocabulary size of the LLaMA model. Defines the number of different tokens that can be represented by the
+            `inputs_ids` passed when calling [`NanbeigeModel`]
+        hidden_size (`int`, *optional*, defaults to 4096):
+            Dimension of the hidden representations.
+        intermediate_size (`int`, *optional*, defaults to 11008):
+            Dimension of the MLP representations.
+        num_hidden_layers (`int`, *optional*, defaults to 32):
+            Number of hidden layers in the Transformer decoder.
+        num_attention_heads (`int`, *optional*, defaults to 32):
+            Number of attention heads for each attention layer in the Transformer decoder.
+        head_dim (`int`, *optional*):
+            Dimension of each attention head. If unset, defaults to `hidden_size // num_attention_heads`.
+        num_key_value_heads (`int`, *optional*):
+            This is the number of key_value heads that should be used to implement Grouped Query Attention. If
+            `num_key_value_heads=num_attention_heads`, the model will use Multi Head Attention (MHA), if
+            `num_key_value_heads=1` the model will use Multi Query Attention (MQA) otherwise GQA is used. When
+            converting a multi-head checkpoint to a GQA checkpoint, each group key and value head should be constructed
+            by meanpooling all the original heads within that group. For more details checkout [this
+            paper](https://arxiv.org/pdf/2305.13245.pdf). If it is not specified, will default to
+            `num_attention_heads`.
+        hidden_act (`str` or `function`, *optional*, defaults to `"silu"`):
+            The non-linear activation function (function or string) in the decoder.
+        max_position_embeddings (`int`, *optional*, defaults to 2048):
+            The maximum sequence length that this model might ever be used with. Nanbeige 1 supports up to 2048 tokens,
+            Nanbeige 2 up to 4096, CodeNanbeige up to 16384.
+        initializer_range (`float`, *optional*, defaults to 0.02):
+            The standard deviation of the truncated_normal_initializer for initializing all weight matrices.
+        rms_norm_eps (`float`, *optional*, defaults to 1e-06):
+            The epsilon used by the rms normalization layers.
+        use_cache (`bool`, *optional*, defaults to `True`):
+            Whether or not the model should return the last key/values attentions (not used by all models). Only
+            relevant if `config.is_decoder=True`.
+        pad_token_id (`int`, *optional*):
+            Padding token id.
+        bos_token_id (`int`, *optional*, defaults to 1):
+            Beginning of stream token id.
+        eos_token_id (`int`, *optional*, defaults to 2):
+            End of stream token id.
+        pretraining_tp (`int`, *optional*, defaults to 1):
+            Experimental feature. Tensor parallelism rank used during pretraining. Please refer to [this
+            document](https://huggingface.co/docs/transformers/main/perf_train_gpu_many#tensor-parallelism) to understand more about it. This value is
+            necessary to ensure exact reproducibility of the pretraining results. Please refer to [this
+            issue](https://github.com/pytorch/pytorch/issues/76232).
+        tie_word_embeddings (`bool`, *optional*, defaults to `False`):
+            Whether to tie weight embeddings
+        rope_theta (`float`, *optional*, defaults to 10000.0):
+            The base period of the RoPE embeddings.
+        rope_scaling (`Dict`, *optional*):
+            Dictionary containing the scaling configuration for the RoPE embeddings. Currently supports two scaling
+            strategies: linear and dynamic. Their scaling factor must be a float greater than 1. The expected format is
+            `{"type": strategy name, "factor": scaling factor}`. When using this flag, don't update
+            `max_position_embeddings` to the expected new maximum. See the following thread for more information on how
+            these scaling strategies behave:
+            https://www.reddit.com/r/LocalLLaMA/comments/14mrgpr/dynamically_scaled_rope_further_increases/. This is an
+            experimental feature, subject to breaking API changes in future versions.
+        attention_bias (`bool`, *optional*, defaults to `False`):
+            Whether to use a bias in the query, key, value and output projection layers during self-attention.
+        attention_dropout (`float`, *optional*, defaults to 0.0):
+            The dropout ratio for the attention probabilities.
+        mlp_bias (`bool`, *optional*, defaults to `False`):
+            Whether to use a bias in up_proj, down_proj and gate_proj layers in the MLP layers.
+        qk_layernorm (`bool`, *optional*, defaults to `False`):
+            Whether to use LayerNorm on query and key states before applying attention.
+        emb_neighbor_num (`int`, *optional*):
+            Maximum N-gram length for N-gram embeddings. This parameter determines the context window size for N-gram computation. Higher values capture
+            longer-range lexical patterns but increase memory usage. If None, N-gram embeddings are disabled.
+        emb_split_num (`int`, *optional*):
+            Number of hash functions (or splits) to use for N-gram embeddings. Multiple hash functions help improve the quality of N-gram representations.
+            Required if emb_neighbor_num is set.
+        ngram_vocab_size_ratio (`float`, *optional*):
+            Ratio multiplier for N-gram vocabulary size relative to the base vocabulary size. The N-gram vocabulary
+            size is calculated as `vocab_size * ngram_vocab_size_ratio`. Required if emb_neighbor_num is set.
+        ngram_mod_force_prime (`bool`, *optional*, defaults to `False`):
+            Whether to use consecutive prime numbers greater than the N-gram base vocabulary size as hash modulo
+            dimensions for N-gram subtables, and the first prime greater than vocab_size as the N-gram hash base.
+        ngram_embedding_hidden_size (`int`, *optional*):
+            Total hidden size used to split N-gram embedding table dimensions. If None, uses `hidden_size`.
+        ngram_fused_mode (`str`, *optional*, defaults to `"average"`):
+            How N-gram embeddings are fused into token embeddings. `"average"` preserves the existing per-table
+            projector and averaging behavior. `"concat"` concatenates raw N-gram table embeddings, projects once to
+            `hidden_size`, and adds the projected N-gram embedding to the token embedding.
+        emb_tp_num (`int`, *optional*):
+            Tensor parallel padding multiplier for N-gram embeddings. The N-gram embedding vocabulary size is padded
+            to the nearest multiple of emb_tp_num. This ensures compatibility with tensor parallel training in Megatron.
+            Required if emb_neighbor_num is set.
+        ngram_compressed_tokenizer (`bool`, *optional*, defaults to `False`):
+            Whether to use compressed tokenizer for N-gram computation. When enabled, the model's tokenizer is used to
+            construct a compressed tokenizer similar to the one in engram_demo_v1.py, which normalizes and deduplicates
+            tokens before computing N-gram hashes.
+        skip_ngram_for_input (`bool`, *optional*, defaults to `False`):
+            Whether to skip adding N-gram embeddings to the input embedding.
+        insert_ngram_layer_idx (`List[int]`, *optional*):
+            0-based decoder layer indices where averaged N-gram embeddings are fused before attention.
+        ngram_insert_all_layers (`bool`, *optional*, defaults to `False`):
+            Whether to fuse averaged N-gram embeddings before attention in every decoder layer.
+        ngram_layer_downproject_size (`int`, *optional*):
+            Optional hidden size for N-gram layer fusion projections. If None, fusion uses `hidden_size`.
+
+    ```python
+    >>> from transformers import NanbeigeModel, NanbeigeConfig
+
+    >>> # Initializing a LLaMA llama-7b style configuration
+    >>> configuration = NanbeigeConfig()
+
+    >>> # Initializing a model from the llama-7b style configuration
+    >>> model = NanbeigeModel(configuration)
+
+    >>> # Accessing the model configuration
+    >>> configuration = model.config
+    ```"""
+
+    model_type = "nanbeige"
+    keys_to_ignore_at_inference = ["past_key_values"]
+
+    def __init__(
+        self,
+        vocab_size=32000,
+        hidden_size=4096,
+        intermediate_size=11008,
+        num_hidden_layers=32,
+        num_attention_heads=32,
+        num_key_value_heads=None,
+        head_dim=None,
+        hidden_act="silu",
+        max_position_embeddings=2048,
+        initializer_range=0.02,
+        rms_norm_eps=1e-6,
+        use_cache=True,
+        pad_token_id=None,
+        bos_token_id=1,
+        eos_token_id=2,
+        pretraining_tp=1,
+        tie_word_embeddings=False,
+        rope_theta=10000.0,
+        rope_scaling=None,
+        attention_bias=False,
+        attention_dropout=0.0,
+        mlp_bias=False,
+        qk_layernorm=False,
+        emb_neighbor_num=None,
+        emb_split_num=None,
+        ngram_vocab_size_ratio=None,
+        ngram_mod_force_prime=False,
+        ngram_embedding_hidden_size=None,
+        ngram_fused_mode="average",
+        emb_tp_num=None,
+        ngram_compressed_tokenizer=False,
+        skip_ngram_for_input=False,
+        insert_ngram_layer_idx=None,
+        ngram_insert_all_layers=False,
+        ngram_layer_downproject_size=None,
+        num_loops=1,
+        loop_loss_weights=None,
+        skip_loop_final_norm=False,
+        enable_double_loop_split=False,
+        loop_middle_layers=None,
+        loop_share_kv=False,
+        mhc_diff_for_loop=False,
+        mhc_double_stream_position_for_loop=None,
+        enable_hyper_connection=False,
+        enable_mhc=False,
+        enable_h_res_identity=False,
+        mhc_identity_nohresparam=False,
+        num_residual_streams=4,
+        mhc_sinkhorn_iterations=20,
+        mhc_init_gating_factor=0.01,
+        enable_depth_attention=False,
+        depth_attention_stride=None,
+        depth_attention_recent_window=0,
+        depth_attention_static_anchor_once=True,
+        **kwargs,
+    ):
+        self.vocab_size = vocab_size
+        self.max_position_embeddings = max_position_embeddings
+        self.hidden_size = hidden_size
+        self.intermediate_size = intermediate_size
+        self.num_hidden_layers = num_hidden_layers
+        self.num_attention_heads = num_attention_heads
+        self.head_dim = head_dim if head_dim is not None else hidden_size // num_attention_heads
+
+        # for backward compatibility
+        if num_key_value_heads is None:
+            num_key_value_heads = num_attention_heads
+
+        self.num_key_value_heads = num_key_value_heads
+        self.hidden_act = hidden_act
+        self.initializer_range = initializer_range
+        self.rms_norm_eps = rms_norm_eps
+        self.pretraining_tp = pretraining_tp
+        self.use_cache = use_cache
+        self.rope_theta = rope_theta
+        self.rope_scaling = rope_scaling
+        self._rope_scaling_validation()
+        self.attention_bias = attention_bias
+        self.attention_dropout = attention_dropout
+        self.mlp_bias = mlp_bias
+        self.qk_layernorm = qk_layernorm
+        self.emb_neighbor_num = emb_neighbor_num
+        self.emb_split_num = emb_split_num
+        self.ngram_vocab_size_ratio = ngram_vocab_size_ratio
+        self.ngram_mod_force_prime = ngram_mod_force_prime
+        self.ngram_embedding_hidden_size = ngram_embedding_hidden_size
+        self.ngram_fused_mode = ngram_fused_mode
+        self.emb_tp_num = emb_tp_num
+        self.ngram_compressed_tokenizer = ngram_compressed_tokenizer
+        self.skip_ngram_for_input = skip_ngram_for_input
+        self.insert_ngram_layer_idx = insert_ngram_layer_idx if insert_ngram_layer_idx is not None else []
+        self.ngram_insert_all_layers = ngram_insert_all_layers
+        self.ngram_layer_downproject_size = ngram_layer_downproject_size
+        self.num_loops = num_loops
+        self.loop_loss_weights = loop_loss_weights if loop_loss_weights is not None else []
+        self.skip_loop_final_norm = skip_loop_final_norm
+        self.enable_double_loop_split = enable_double_loop_split
+        self.loop_middle_layers = loop_middle_layers
+        self.loop_share_kv = loop_share_kv
+        self.mhc_diff_for_loop = mhc_diff_for_loop
+        self.mhc_double_stream_position_for_loop = mhc_double_stream_position_for_loop
+        self.enable_hyper_connection = enable_hyper_connection
+        self.enable_mhc = enable_mhc
+        self.enable_h_res_identity = enable_h_res_identity
+        self.mhc_identity_nohresparam = mhc_identity_nohresparam
+        self.num_residual_streams = num_residual_streams
+        self.mhc_sinkhorn_iterations = mhc_sinkhorn_iterations
+        self.mhc_init_gating_factor = mhc_init_gating_factor
+        self.enable_depth_attention = enable_depth_attention
+        self.depth_attention_stride = depth_attention_stride
+        self.depth_attention_recent_window = depth_attention_recent_window
+        self.depth_attention_static_anchor_once = depth_attention_static_anchor_once
+        self._hyper_connection_validation()
+
+        super().__init__(
+            pad_token_id=pad_token_id,
+            bos_token_id=bos_token_id,
+            eos_token_id=eos_token_id,
+            tie_word_embeddings=tie_word_embeddings,
+            **kwargs,
+        )
+
+    def _rope_scaling_validation(self):
+        """
+        Validate the `rope_scaling` configuration.
+        """
+        if self.rope_scaling is None:
+            return
+
+        if not isinstance(self.rope_scaling, dict) or len(self.rope_scaling) != 2:
+            raise ValueError(
+                "`rope_scaling` must be a dictionary with two fields, `type` and `factor`, " f"got {self.rope_scaling}"
+            )
+        rope_scaling_type = self.rope_scaling.get("type", None)
+        rope_scaling_factor = self.rope_scaling.get("factor", None)
+        if rope_scaling_type is None or rope_scaling_type not in ["linear", "dynamic"]:
+            raise ValueError(
+                f"`rope_scaling`'s type field must be one of ['linear', 'dynamic'], got {rope_scaling_type}"
+            )
+        if rope_scaling_factor is None or not isinstance(rope_scaling_factor, float) or rope_scaling_factor <= 1.0:
+            raise ValueError(f"`rope_scaling`'s factor field must be a float > 1, got {rope_scaling_factor}")
+
+    def _hyper_connection_validation(self):
+        if self.mhc_diff_for_loop and not self.enable_double_loop_split:
+            raise ValueError("mhc_diff_for_loop requires enable_double_loop_split=True.")
+        if self.mhc_diff_for_loop and not self.enable_mhc:
+            raise ValueError("mhc_diff_for_loop requires enable_mhc=True.")
+        if self.loop_share_kv and not self.enable_double_loop_split:
+            raise ValueError("loop_share_kv requires enable_double_loop_split=True.")
+        if self.enable_depth_attention:
+            if self.num_hidden_layers <= 0:
+                raise ValueError("enable_depth_attention requires num_hidden_layers to be greater than 0.")
+            if self.depth_attention_stride is None:
+                self.depth_attention_stride = self.num_hidden_layers // 2
+            if self.depth_attention_stride <= 0:
+                raise ValueError("depth_attention_stride must be greater than 0.")
+            if self.depth_attention_recent_window < 0:
+                raise ValueError("depth_attention_recent_window must be >= 0.")
+            if self.depth_attention_recent_window != 0:
+                raise ValueError("anchor-only Depth-Attention requires depth_attention_recent_window == 0.")
+            if self.enable_double_loop_split and not self.depth_attention_static_anchor_once:
+                raise ValueError(
+                    "enable_depth_attention with double-loop split requires "
+                    "depth_attention_static_anchor_once=True."
+                )
+        if self.mhc_double_stream_position_for_loop is not None:
+            if self.mhc_double_stream_position_for_loop not in ("mid", "edge"):
+                raise ValueError("mhc_double_stream_position_for_loop must be one of: mid, edge.")
+            if not self.enable_double_loop_split:
+                raise ValueError(
+                    "mhc_double_stream_position_for_loop requires enable_double_loop_split=True."
+                )
+        if (self.enable_mhc or self.enable_h_res_identity) and not self.enable_hyper_connection:
+            raise ValueError(
+                "enable_mhc/enable_h_res_identity require enable_hyper_connection=True."
+            )
+        if self.mhc_identity_nohresparam:
+            if not self.enable_h_res_identity:
+                raise ValueError("mhc_identity_nohresparam requires enable_h_res_identity=True.")
+            if not self.enable_mhc:
+                raise ValueError("mhc_identity_nohresparam requires enable_mhc=True.")
+        if self.enable_hyper_connection and self.num_residual_streams < 2:
+            raise ValueError("num_residual_streams must be >= 2 when enable_hyper_connection=True.")
+        if self.enable_mhc and self.mhc_sinkhorn_iterations < 1:
+            raise ValueError("mhc_sinkhorn_iterations must be >= 1 when enable_mhc=True.")
+        if self.ngram_insert_all_layers and self.insert_ngram_layer_idx:
+            raise ValueError("ngram_insert_all_layers cannot be used with insert_ngram_layer_idx.")
+        if self.ngram_layer_downproject_size is not None and self.ngram_layer_downproject_size <= 0:
+            raise ValueError("ngram_layer_downproject_size must be greater than 0 when set.")
+        if self.ngram_embedding_hidden_size is not None and self.ngram_embedding_hidden_size <= 0:
+            raise ValueError("ngram_embedding_hidden_size must be greater than 0 when set.")
+        if self.ngram_fused_mode not in ("average", "concat"):
+            raise ValueError("ngram_fused_mode must be one of: average, concat.")
+        if (
+            not self.enable_double_loop_split
+            and self.loop_loss_weights is not None
+            and sum(self.loop_loss_weights) > 1.0
+        ):
+            raise ValueError("sum(loop_loss_weights) must be <= 1.0.")
+        if self.enable_double_loop_split and self.loop_middle_layers is None:
+            if self.num_hidden_layers <= 0:
+                raise ValueError("enable_double_loop_split requires num_hidden_layers to be greater than 0.")
+            if self.num_hidden_layers % 2 != 0:
+                raise ValueError(
+                    "enable_double_loop_split requires num_hidden_layers to be divisible by 2 "
+                    "when loop_middle_layers is not set."
+                )
+            self.loop_middle_layers = self.num_hidden_layers // 2
+        if self.loop_middle_layers is not None:
+            if self.num_hidden_layers <= 0:
+                raise ValueError("loop_middle_layers requires num_hidden_layers to be greater than 0.")
+            if self.loop_middle_layers <= 0:
+                raise ValueError("loop_middle_layers must be greater than 0.")
+            if self.num_hidden_layers % self.loop_middle_layers != 0:
+                raise ValueError("loop_middle_layers must be a factor of num_hidden_layers.")

generation_config.json

@@ -0,0 +1,10 @@
+{
+  "bos_token_id": 166100,
+  "do_sample": true,
+  "eos_token_id": 166101,
+  "pad_token_id": 0,
+  "temperature": 0.6,
+  "top_k": 20,
+  "top_p": 0.95,
+  "transformers_version": "4.51.0"
+}

special_tokens_map.json

@@ -0,0 +1,33 @@
+{
+  "additional_special_tokens": [
+    "<|endoftext|>"
+  ],
+  "bos_token": {
+    "content": "<|im_start|>",
+    "lstrip": false,
+    "normalized": false,
+    "rstrip": false,
+    "single_word": false
+  },
+  "eos_token": {
+    "content": "<|im_end|>",
+    "lstrip": false,
+    "normalized": false,
+    "rstrip": false,
+    "single_word": false
+  },
+  "pad_token": {
+    "content": "<unk>",
+    "lstrip": false,
+    "normalized": true,
+    "rstrip": false,
+    "single_word": false
+  },
+  "unk_token": {
+    "content": "<unk>",
+    "lstrip": false,
+    "normalized": true,
+    "rstrip": false,
+    "single_word": false
+  }
+}

tokenizer.json

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

tokenizer.model

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

tokenizer_config.json

@@ -0,0 +1,103 @@
+{
+  "add_bos_token": true,
+  "add_eos_token": false,
+  "add_prefix_space": true,
+  "added_tokens_decoder": {
+    "0": {
+      "content": "<unk>",
+      "lstrip": false,
+      "normalized": true,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "1": {
+      "content": "<s>",
+      "lstrip": false,
+      "normalized": true,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "2": {
+      "content": "</s>",
+      "lstrip": false,
+      "normalized": true,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "166100": {
+      "content": "<|im_start|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "166101": {
+      "content": "<|im_end|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "166102": {
+      "content": "<|endoftext|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "166103": {
+      "content": "<think>",
+      "lstrip": false,
+      "normalized": true,
+      "rstrip": false,
+      "single_word": false,
+      "special": false
+    },
+    "166104": {
+      "content": "</think>",
+      "lstrip": false,
+      "normalized": true,
+      "rstrip": false,
+      "single_word": false,
+      "special": false
+    },
+    "166105": {
+      "content": "<tool_call>",
+      "lstrip": false,
+      "normalized": true,
+      "rstrip": false,
+      "single_word": false,
+      "special": false
+    },
+    "166106": {
+      "content": "</tool_call>",
+      "lstrip": false,
+      "normalized": true,
+      "rstrip": false,
+      "single_word": false,
+      "special": false
+    }
+  },
+  "additional_special_tokens": [
+    "<|endoftext|>"
+  ],
+  "bos_token": "<|im_start|>",
+  "chat_template": "\n\n{%- macro visible_text(content) -%}\n    {%- if content is string -%}\n        {{- content }}\n    {%- elif content is iterable and content is not mapping -%}\n        {%- for item in content -%}\n            {%- if item is mapping and item.type == 'text' -%}\n                {{- item.text }}\n            {%- elif item is string -%}\n                {{- item }}\n            {%- elif item is mapping and item.type in ['image', 'image_url', 'video', 'video_url', 'audio', 'audio_url', 'input_audio'] -%}\n                {%- set media_type = item.type | replace('_url', '') | replace('input_', '') -%}\n                {{- \"<reminder>You are unable to process this \" ~ media_type ~ \" because you don't have multi-modal input ability. Try different methods.</reminder>\" }}\n            {%- endif -%}\n        {%- endfor -%}\n    {%- else -%}\n        {{- content }}\n    {%- endif -%}\n{%- endmacro -%}\n\n\n{%- set tool_call_format = tool_call_format if tool_call_format is defined else 'xml' %}\n{%- if tools %}\n    {{- '<|im_start|>system\\n' }}    \n    {%- if messages|length > 0 and messages[0].get('role', '') == 'system' %}\n        {{- visible_text(messages[0].content) + '\\n\\n' }}\n    {%- else %} \n        {{- '你是一位工具函数调用专家，你会得到一个问题和一组可能的工具函数。根据问题，你需要进行一个或多个函数/工具调用以实现目的，请尽量尝试探索通过工具解决问题。\\n如果没有一个函数可以使用，请直接使用自然语言回复用户。\\n如果给定的问题缺少函数所需的参数，请使用自然语言进行提问，向用户询问必要信息。\\n如果调用结果已经足够回答用户问题，请对历史结果进行总结，使用自然语言回复用户。' }} \n    {%- endif %}\n\n    {{- \"# 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>\" }}\n    {%- for tool in tools %}\n        {{- \"\\n\" }}\n        {{- tool | tojson }}\n    {%- endfor %}\n    \n    {%- if tool_call_format == 'json' %}\n        {{- \"\\n</tools>\\n\\nFor each function call, return a json object with function name and arguments within <tool_call></tool_call> XML tags:\\n\" }}\n        {{- '<tool_call>\\n{\\\"name\\\": <function-name>, \\\"arguments\\\": <args-json-object>}\\n</tool_call><|im_end|>\\n' }}\n    {%- else %}\n        {{- \"\\n</tools>\\n\\nFor each function call, output the function name and arguments within the following XML format:\\n\" }}\n        {{- '<tool_call>\n<function=example_function_name>\n<parameter=example_parameter_1>\nvalue_1\n</parameter>\n<parameter=example_parameter_2>\nThis is the value for the second parameter\nthat can span\nmultiple lines\n</parameter>\n</function>\n</tool_call><|im_end|>\\n' }}\n    {%- endif %}\n    \n{%- else %}\n    {%- if messages|length > 0 and messages[0].get('role', '') == 'system' %}\n        {{- '<|im_start|>system\\n' + visible_text(messages[0].content) + '<|im_end|>\\n' }}\n    {%- else %} \n        {{- '<|im_start|>system\\n你是南北阁，一款由BOSS直聘自主研发并训练的专业大语言模型。<|im_end|>\\n' }} \n    {%- endif %}\n{%- endif %}\n\n{%- set ns = namespace(multi_step_tool=true, last_query_index=messages|length - 1) %}\n{%- for message in messages[::-1] %}\n    {%- set index = (messages|length - 1) - loop.index0 %}\n    {%- if ns.multi_step_tool and message.get('role', '') == \"user\" and visible_text(message.content) is string and not(visible_text(message.content).startswith('<tool_response>') and visible_text(message.content).endswith('</tool_response>')) %}\n        {%- set ns.multi_step_tool = false %}\n        {%- set ns.last_query_index = index %}\n    {%- endif %}\n{%- endfor %}\n\n{%- for message in messages %}\n    {%- if visible_text(message.content) is string %}\n        {%- set content = visible_text(message.content) %}\n    {%- else %}\n        {%- set content = '' %}\n    {%- endif %}\n    \n    {%- if message.get('role', '') == \"system\" %}\n        {%- if not loop.first %}\n            {{- raise_exception('System message must be at the beginning.') }}\n        {%- endif %}\n        \n    {%- elif message.get('role', '') == \"assistant\" %}\n        {%- set reasoning_content = '' %}\n        {%- if message.reasoning_content is string %}\n            {%- set reasoning_content = message.reasoning_content %}\n        {%- else %}\n            {%- if '</think>' in content %}\n                {%- set reasoning_content = content.split('</think>')[0].rstrip('\\n').split('<think>')[-1].lstrip('\\n') %}\n                {%- set content = content.split('</think>')[-1].lstrip('\\n') %}\n            {%- endif %}\n        {%- endif %}\n        {%- set reasoning_content = reasoning_content|trim %}\n        \n        {%- if (preserve_thinking is defined and preserve_thinking is false) and (loop.index0 < ns.last_query_index) %}\n            {{- '<|im_start|>' + message.get('role', '') + '\\n<think>\\n\\n</think>\\n\\n' + content }}\n        {%- else %}\n            {{- '<|im_start|>' + message.get('role', '') + '\\n<think>\\n' + reasoning_content + '\\n</think>\\n\\n' + content }}\n        {%- endif %}\n        \n        {%- if message.tool_calls and message.tool_calls is iterable and message.tool_calls is not mapping %}\n            {%- if tool_call_format == 'json' %}\n                {%- for tool_call in message.tool_calls %}\n                    {%- if (loop.first and content) or (not loop.first) %}\n                        {{- '\\n' }}\n                    {%- endif %}\n                    {%- if tool_call.function %}\n                        {%- set tool_call = tool_call.function %}\n                    {%- endif %}\n                    {{- '<tool_call>\\n{\"name\": \"' }}\n                    {{- tool_call.name }}\n                    {{- '\", \"arguments\": ' }}\n                    {%- if tool_call.arguments is string %}\n                        {{- tool_call.arguments }}\n                    {%- else %}\n                        {{- tool_call.arguments | tojson }}\n                    {%- endif %}\n                    {{- '}\\n</tool_call>' }}\n                {%- endfor %}\n            {%- else %}\n                {%- for tool_call in message.tool_calls %}\n                    {%- if tool_call.function is defined %}\n                        {%- set tool_call = tool_call.function %}\n                    {%- endif %}\n                    \n                    {%- if loop.first %}\n                        {%- if content|trim %}\n                            {{- '\n\n<tool_call>\n<function=' + tool_call.name + '>\n' }}\n                        {%- else %}\n                            {{- '<tool_call>\n<function=' + tool_call.name + '>\n' }}\n                        {%- endif %}\n                    {%- else %}\n                        {{- '\n<tool_call>\n<function=' + tool_call.name + '>\n' }}\n                    {%- endif %}\n                    \n                    {%- if tool_call.arguments is defined %}\n                        {%- for args_name, args_value in tool_call.arguments|items %}\n                            {{- '<parameter=' + args_name + '>\n' }}\n                            {%- set args_value = args_value | string if args_value is string else args_value | tojson | safe %}\n                            {{- args_value }}\n                            {{- '\n</parameter>\n' }}\n                        {%- endfor %}\n                    {%- endif %}\n                    {{- '</function>\n</tool_call>' }}\n                {%- endfor %}\n            {%- endif %}\n        {%- endif %}\n        {{- '<|im_end|>\\n' }}\n        \n    {%- elif message.get('role', '') == \"tool\" %}\n        {%- if loop.previtem and loop.previtem.get('role', '') != \"tool\" %}\n            {{- '<|im_start|>user' }}\n        {%- endif %}\n        {{- '\\n<tool_response>\\n' }}\n        {{- content }}\n        {{- '\\n</tool_response>' }}\n        {%- if loop.last or loop.nextitem.get('role', '') != \"tool\" %}\n            {{- '<|im_end|>\\n' }}\n        {%- endif %}\n    {%- elif message.get('role', '') != '' %}\n        {{- '<|im_start|>' + message.get('role', '') + '\\n' + content + '<|im_end|>' + '\\n' }}\n    {%- endif %}\n{%- endfor %}\n\n{%- if add_generation_prompt %}\n    {{- '<|im_start|>assistant\\n' }}\n    \n    {%- if enable_thinking is defined and enable_thinking is false %}\n        {{- '<think>\n\n</think>\n\n' }}\n    {%- else %}\n        {{- '<think>\n' }}\n    {%- endif %}\n    \n{%- endif %}\n",
+  "clean_up_tokenization_spaces": false,
+  "eos_token": "<|im_end|>",
+  "extra_special_tokens": {},
+  "legacy": false,
+  "model_max_length": 1000000000000000019884624838656,
+  "pad_token": "<unk>",
+  "sp_model_kwargs": {},
+  "spaces_between_special_tokens": false,
+  "tokenizer_class": "LlamaTokenizer",
+  "unk_token": "<unk>",
+  "use_default_system_prompt": false
+}